C++如何实现复合类型与标准容器结合

struct MyData {     int id;     std::String name;     // 默认构造函数     MyData() : id(0), name("default") {}     // 带参数构造函数     MyData(int i, const std::string& n) : id(i), name(n) {}      // 为了在某些容器（如std::set, std::map的键）中使用，可能需要比较操作符     bool operator<(const MyData& other) const {         return id < other.id;     }     // 为了在std::unordered_map/set中使用，需要相等操作符     bool operator==(const MyData& other) const {         return id == other.id && name == other.name;     } };  // 使用 std::vector<MyData> dataVec; dataVec.push_back(MyData(1, "Alice")); dataVec.emplace_back(2, "Bob"); // 更高效，直接在容器内部构造  std::map<int, MyData> dataMap; dataMap[3] = MyData(3, "Charlie");  std::set<MyData> dataSet; dataSet.insert(MyData(4, "David"));

class Base { public:     virtual void print() const = 0;     virtual ~Base() = default; };  class DerivedA : public Base { public:     void print() const override { std::cout << "DerivedAn"; } };  class DerivedB : public Base { public:     void print() const override { std::cout << "DerivedBn"; } };  // 使用 std::vector<std::unique_ptr<Base>> objects; objects.push_back(std::make_unique<DerivedA>()); objects.push_back(std::make_unique<DerivedB>());  for (const auto& p : objects) {     p->print(); }  // 如果需要共享所有权 std::vector<std::shared_ptr<MyData>> sharedDataVec; auto d1 = std::make_shared<MyData>(5, "Eve"); sharedDataVec.push_back(d1); sharedDataVec.push_back(std::make_shared<MyData>(6, "Frank"));

struct ComplexObject {     std::string large_string;     std::vector<int> large_vector;      ComplexObject(const std::string& s, int count) : large_string(s) {         large_vector.resize(count);         // ... 更多复杂的初始化     }     // 拷贝构造函数可能很昂贵     ComplexObject(const ComplexObject& other) = default;     // 移动构造函数可以优化     ComplexObject(ComplexObject&& other) noexcept = default; };  std::vector<ComplexObject> objects; // 低效：先构造临时对象，再拷贝/移动 objects.push_back(ComplexObject("data_A", 1000)); // 高效：直接在vector内部构造 objects.emplace_back("data_B", 1000);

std::vector::reserve()

std::list

std::deque

int

Key

创一AI

ai帮你写短视频脚本

155

查看详情

Comparator

struct Point {     int x, y;     // 必须提供operator<，用于std::map/std::set的排序     bool operator<(const Point& other) const {         if (x != other.x) {             return x < other.x;         }         return y < other.y;     } };  std::set<Point> uniquePoints; uniquePoints.insert({1, 2}); uniquePoints.insert({2, 1}); uniquePoints.insert({1, 2}); // 不会重复插入  std::map<Point, std::string> pointNames; pointNames[{1, 2}] = "Center"; pointNames[{0, 0}] = "Origin";

struct PointComparator {     bool operator()(const Point& a, const Point& b) const {         // 比如，我们想按y坐标优先排序         if (a.y != b.y) {             return a.y < b.y;         }         return a.x < b.x;     } }; std::set<Point, PointComparator> customSortedPoints;

#include <functional> // for std::hash  struct PointHash {     size_t operator()(const Point& p) const {         // 一个简单的哈希组合，实际应用中可能需要更复杂的算法         return std::hash<int>()(p.x) ^ (std::hash<int>()(p.y) << 1);     } };  // 如果在Point结构体内部定义operator== // bool operator==(const Point& other) const { //     return x == other.x && y == other.y; // }  std::unordered_set<Point, PointHash> unorderedPoints; unorderedPoints.insert({1, 2});  std::unordered_map<Point, std::string, PointHash> unorderedPointNames; unorderedPointNames[{1, 2}] = "Center";

set

map

class MyResource { private:     int* data;     size_t size;  public:     // 构造函数：分配资源     MyResource(size_t s) : size(s), data(new int[s]) {         std::cout << "MyResource constructed, size: " << size << "n";     }      // 析构函数：释放资源     ~MyResource() {         std::cout << "MyResource destructed, size: " << size << "n";         delete[] data;     }      // 拷贝构造函数：深拷贝，避免多个对象指向同一资源     MyResource(const MyResource& other) : size(other.size), data(new int[other.size]) {         std::copy(other.data, other.data + other.size, data);         std::cout << "MyResource copy constructed, size: " << size << "n";     }      // 拷贝赋值运算符：深拷贝，处理自赋值和资源清理     MyResource& operator=(const MyResource& other) {         if (this != &other) { // 避免自赋值             delete[] data; // 释放旧资源             size = other.size;             data = new int[other.size];             std::copy(other.data, other.data + other.size, data);         }         std::cout << "MyResource copy assigned, size: " << size << "n";         return *this;     }      // 移动构造函数：转移资源所有权，避免不必要的深拷贝     MyResource(MyResource&& other) noexcept : data(other.data), size(other.size) {         other.data = nullptr; // 源对象不再拥有资源         other.size = 0;         std::cout << "MyResource move constructed, size: " << size << "n";     }      // 移动赋值运算符：转移资源所有权     MyResource& operator=(MyResource&& other) noexcept {         if (this != &other) {             delete[] data; // 释放旧资源             data = other.data;             size = other.size;             other.data = nullptr;             other.size = 0;         }         std::cout << "MyResource move assigned, size: " << size << "n";         return *this;     } };  // 容器操作 std::vector<MyResource> resources; resources.reserve(2); // 预留空间，减少重新分配 resources.push_back(MyResource(10)); // 触发移动构造 resources.emplace_back(20);          // 直接构造，可能触发移动构造（取决于编译器优化）

 // 使用智能指针管理资源，遵循“零法则” class MyResourceSmart { private:     std::unique_ptr<int[]> data; // 使用unique_ptr管理动态数组     size_t size;  public:     MyResourceSmart(size_t s) : size(s), data(std::make_unique<int[]>(s)) {         std::cout << "MyResourceSmart constructed, size: " << size << "n";     }     // 默认的析构、拷贝、移动函数都能正常工作！     // 拷贝构造：会调用unique_ptr的拷贝构造（但unique_ptr没有拷贝构造，需要自己实现深拷贝）     // 如果需要拷贝，可以这样实现：     MyResourceSmart(const MyResourceSmart& other) : size(other.size), data(std::make_unique<int[]>(other.size)) {         std::copy(other.data.get(), other.data.get() + other.size, data.get());         std::cout << "MyResourceSmart copy constructed (deep), size: " << size << "n";     }     // 移动构造：unique_ptr有移动构造，默认即可     MyResourceSmart(MyResourceSmart&& other) noexcept = default;     MyResourceSmart& operator=(MyResourceSmart&& other) noexcept = default;     // 拷贝赋值     MyResourceSmart& operator=(const MyResourceSmart& other) {         if (this != &other) {             size = other.size;             data = std::make_unique<int

大家都在看：