【绝对有用】C++ 字符串进行排序、vector增加内容 和 剔除值

在 C++ 中对字符串进行排序，可以使用标准库中的 std::sort 函数。std::sort 函数可以用于容器或范围内的元素排序，包括字符串中的字符。以下是一个简单的示例代码，展示了如何对字符串中的字符进行排序：

#include <iostream>
#include <algorithm> // std::sort
#include <string> // std::string

int main() {
    std::string str = "hello world";

    // 使用 std::sort 对字符串进行排序
    std::sort(str.begin(), str.end());

    // 输出排序后的字符串
    std::cout << "Sorted string: " << str << std::endl;

    return 0;
}

在这个示例中，std::sort(str.begin(), str.end()) 对 str 中的字符进行排序。str.begin() 返回指向字符串开头的迭代器，str.end() 返回指向字符串末尾后一个位置的迭代器。std::sort 函数将这两个迭代器之间的字符按升序排序。

运行以上代码后，输出将是：

Sorted string:  dehllloorw

你可以根据需要修改字符串或排序条件，例如按降序排序，可以传递一个自定义的比较函数给 std::sort：

std::sort(str.begin(), str.end(), std::greater<char>());

---

在 C++ 中，向 std::vector<std::vector<std::string>> 类型的容器中添加值，可以使用 push_back 方法。以下是一些示例，展示了如何向 std::vector<std::vector<std::string>> 中添加值：

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::vector<std::string>> res;

    // 创建一个新的字符串向量
    std::vector<std::string> newVector = {"hello", "world"};

    // 将新的字符串向量添加到 res 中
    res.push_back(newVector);

    // 直接向 res 中添加一个包含两个字符串的向量
    res.push_back({"foo", "bar"});

    // 输出 res 中的内容
    for (const auto& vec : res) {
        for (const auto& str : vec) {
            std::cout << str << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

在这个示例中：

1. 创建了一个 std::vector<std::vector<std::string>> 类型的变量 res。
2. 使用 push_back 方法将一个新的 std::vector<std::string> 类型的变量 newVector 添加到 res 中。
3. 使用 push_back 方法直接向 res 中添加一个包含两个字符串的向量。
4. 遍历并输出 res 中的内容。

运行这段代码后，输出将是：

hello world 
foo bar 

你还可以使用其他方式向 res 中添加值，例如通过索引访问来修改已有的向量：

res[0].push_back("new string");

但请确保在这样做之前，res 中已经包含了至少一个向量，否则会导致越界访问错误。

---

在 C++ 中，要从一个容器（例如 std::vector）中移除遍历的值，通常不能在范围 for 循环中直接进行，因为这会导致迭代器失效。相反，可以使用标准库中的 erase 函数配合迭代器进行操作。

一种常见的做法是使用 std::remove_if 配合 erase，以安全地移除满足特定条件的元素。以下是一个示例，展示了如何从一个 std::vector<std::string> 中移除满足特定条件的字符串：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> // std::remove_if

int main() {
    std::vector<std::string> strs = {"hello", "world", "foo", "bar"};

    // 移除满足条件的字符串
    // 例如：移除所有等于 "foo" 的字符串
    strs.erase(std::remove_if(strs.begin(), strs.end(),
        [](const std::string& str) {
            return str == "foo"; // 条件：字符串等于 "foo"
        }), strs.end());

    // 输出剩余的字符串
    for (const auto& str : strs) {
        std::cout << str << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中：

1. std::remove_if 用于将所有满足条件的元素移动到容器的末尾，并返回指向第一个满足条件的元素的迭代器。
2. erase 函数用于移除这些元素。

如果你需要在遍历过程中移除元素，建议使用迭代器进行遍历：

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> strs = {"hello", "world", "foo", "bar"};

    // 使用迭代器遍历并移除满足条件的字符串
    for (auto it = strs.begin(); it != strs.end(); ) {
        if (*it == "foo") {
            it = strs.erase(it); // 移除元素并更新迭代器
        } else {
            ++it; // 仅在未移除元素时递增迭代器
        }
    }

    // 输出剩余的字符串
    for (const auto& str : strs) {
        std::cout << str << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中：

1. 使用迭代器 it 遍历 strs。
2. 如果当前元素满足条件（例如等于 “foo”），则使用 erase 函数移除该元素，并更新迭代器。
3. 如果当前元素不满足条件，则仅递增迭代器。

这样可以安全地在遍历过程中移除元素。

---

在 C++ 中，可以使用多种方法来判断两个字符串是否相等。以下是几种常见的方法：

方法1：使用 == 操作符

C++ 标准库中的 std::string 类重载了 == 操作符，因此可以直接使用 == 来比较两个字符串是否相等。

#include <iostream>
#include <string>

int main() {
    std::string str1 = "hello";
    std::string str2 = "hello";

    if (str1 == str2) {
        std::cout << "The strings are equal." << std::endl;
    } else {
        std::cout << "The strings are not equal." << std::endl;
    }

    return 0;
}

方法2：使用 compare 函数

std::string 类提供了一个 compare 成员函数，可以用来比较两个字符串。如果两个字符串相等，compare 函数返回 0。

#include <iostream>
#include <string>

int main() {
    std::string str1 = "hello";
    std::string str2 = "hello";

    if (str1.compare(str2) == 0) {
        std::cout << "The strings are equal." << std::endl;
    } else {
        std::cout << "The strings are not equal." << std::endl;
    }

    return 0;
}

方法3：使用 C 风格字符串的 strcmp 函数

如果你使用的是 C 风格的字符串（字符数组），可以使用 strcmp 函数进行比较。这个函数在 <cstring> 头文件中定义。

#include <iostream>
#include <cstring>

int main() {
    const char* str1 = "hello";
    const char* str2 = "hello";

    if (std::strcmp(str1, str2) == 0) {
        std::cout << "The strings are equal." << std::endl;
    } else {
        std::cout << "The strings are not equal." << std::endl;
    }

    return 0;
}

方法4：使用循环逐字符比较

你也可以手动编写一个循环来逐字符比较两个字符串，不过这种方法通常不如前面的方法简洁和高效。

#include <iostream>
#include <string>

bool areStringsEqual(const std::string& str1, const std::string& str2) {
    if (str1.length() != str2.length()) {
        return false;
    }

    for (size_t i = 0; i < str1.length(); ++i) {
        if (str1[i] != str2[i]) {
            return false;
        }
    }

    return true;
}

int main() {
    std::string str1 = "hello";
    std::string str2 = "hello";

    if (areStringsEqual(str1, str2)) {
        std::cout << "The strings are equal." << std::endl;
    } else {
        std::cout << "The strings are not equal." << std::endl;
    }

    return 0;
}

总结

最常用和推荐的方法是使用 == 操作符或者 compare 函数，因为它们简洁且易于理解。对于 C 风格的字符串，strcmp 函数是一个常用的选择。手动逐字符比较的方法虽然也能完成任务，但不如前几种方法简洁和高效。

---

在C++中，使用vector::erase时，需要注意的是，调用erase后，迭代器it将变得无效。因为erase函数会导致容器的元素位置发生变化，这样会使得循环中的it指针变得不正确，从而导致意想不到的行为。

为了正确地在遍历时删除元素，我们需要使用一种安全的迭代器处理方式，比如在erase之后更新迭代器。可以使用以下代码：

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

int main() {
    std::vector<std::string> uniqueWord = {"aet", "ant", "bat"};
    std::vector<std::string> strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
    std::vector<std::vector<std::string>> res;

    for (const auto& elem : uniqueWord) {
        std::vector<std::string> tempRes;
        for (auto it = strs.begin(); it != strs.end(); ) {
            std::string tempStr = *it;
            std::sort(tempStr.begin(), tempStr.end());
            if (elem == tempStr) {
                tempRes.push_back(*it);
                it = strs.erase(it); // 删除元素并更新迭代器
            } else {
                ++it; // 仅在未删除元素时递增迭代器
            }
        }
        res.push_back(tempRes);
    }

    // 输出结果
    for (const auto& vec : res) {
        for (const auto& str : vec) {
            std::cout << str << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

在这段代码中：

1. 使用auto it = strs.begin();初始化迭代器。
2. 在循环中，当满足条件时，使用it = strs.erase(it);删除元素，并更新迭代器。
3. 如果条件不满足，仅递增迭代器++it;。

这样可以确保迭代器在删除元素后依然有效，防止删除非目标元素。通过这种方法，能够正确、安全地删除符合条件的元素。