c++怎么在vector里添加自定义结构体，自定义结构体包含一个类对象和一个整形

可以使用类似于以下代码的方式向 `vector` 中添加自定义结构体：

#include <vector>

// 自定义结构体
struct MyStruct {
    MyClass myClassObj;
    int myInt;
};

int main() {
    std::vector<MyStruct> myVector;

    // 创建一个 MyStruct 对象并添加到 vector 中
    MyStruct myStructObj;
    myStructObj.myClassObj = MyClass();  // 初始化 myClassObj
    myStructObj.myInt = 123;
    myVector.push_back(myStructObj);

    // 或者直接在 push_back 中初始化 MyStruct 对象
    myVector.push_back({MyClass(), 456});

    return 0;
}

其中 `MyClass` 是自定义类，你需要根据实际情况填写。

相关问题

c++ 递归去除vector 中重复自定义结构体

在C++中，如果你有一个自定义结构体并且想要从`std::vector`中移除所有重复项，可以使用递归来遍历并检查每个元素是否已经存在于集合中。这里是一个简单的例子，假设你的结构体名为`MyStruct`：

#include <iostream>
#include <vector>
#include <unordered_set>

// 自定义结构体 MyStruct
struct MyStruct {
    // 假设这里有两个字段用于唯一标识
    int field1;
    std::string field2;

    bool operator==(const MyStruct& other) const {
        return field1 == other.field1 && field2 == other.field2;
    }
};

// 使用一个无序集合（Set）来存储已见的元素
std::unordered_set<MyStruct> seenElements;

// 递归函数，接收vector和索引作为参数
void removeDuplicates(std::vector<MyStruct>& vec, size_t index = 0) {
    if (index >= vec.size()) {
        // 如果已到达末尾，结束递归
        return;
    }

    // 检查当前元素是否已经在集合中
    if (seenElements.find(vec[index]) != seenElements.end()) {
        // 如果存在，则删除并继续处理下一个
        vec.erase(vec.begin() + index);
        return removeDuplicates(vec, index); // 递归调用，跳过已删除的位置
    } else {
        // 如果不存在，添加到集合中然后进入下一层迭代
        seenElements.insert(vec[index]);
        return removeDuplicates(vec, index + 1);
    }
}

int main() {
    std::vector<MyStruct> myVector = { /* ... */ }; // 填充你的向量

    removeDuplicates(myVector);

    // 输出处理后的vector
    for (const auto& item : myVector) {
        std::cout << "Item: {" << item.field1 << ", " << item.field2 << "}\n";
    }

    return 0;
}

在这个示例中，`removeDuplicates` 函数会通过递归地比较每个元素和之前见过的元素来移除重复。如果遇到重复，就从向量中删除该元素，并调整递归调用的索引来忽略已删除的元素。

给vector写一个快速排序，vector中装的是自定义结构体

好的，以下是一个使用快速排序算法对vector中自定义结构体进行排序的示例代码：

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

struct MyStruct {
    int id;
    std::string name;
};

bool operator<(const MyStruct& s1, const MyStruct& s2) {
    return s1.id < s2.id;
}

void quickSort(std::vector<MyStruct>& v, int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = v[(left + right) / 2].id;
    int i = left - 1;
    int j = right + 1;
    while (i < j) {
        do {
            i++;
        } while (v[i].id < pivot);
        do {
            j--;
        } while (v[j].id > pivot);
        if (i < j) {
            std::swap(v[i], v[j]);
        }
    }
    quickSort(v, left, j);
    quickSort(v, j + 1, right);
}

int main() {
    std::vector<MyStruct> v{{3, "C"}, {1, "A"}, {4, "D"}, {2, "B"}};
    quickSort(v, 0, v.size() - 1);
    for (const auto& s : v) {
        std::cout << s.id << " " << s.name << std::endl;
    }
    return 0;
}

在自定义结构体中，我们需要重载小于运算符，以便在排序时可以比较结构体的id属性。快速排序算法的实现跟普通数组的排序类似，不同的是需要在交换元素时使用vector的成员函数std::swap。