C++如何使用STL容器存储自定义对象-C++-PHP中文网

将自定义对象存入STL容器需满足拷贝、移动、默认构造及比较操作要求。推荐优先使用值语义存储，对象需实现拷贝/移动构造函数、赋值运算符及必要的比较操作符；对于大对象或需多态时，应使用智能指针（如std::unique_ptr、std::shared_ptr）管理生命周期，并注意避免对象切片问题。无序容器需自定义哈希函数和operator==，有序容器需重载operator<以满足严格弱序。

c++如何使用stl容器存储自定义对象

在C++中，将自定义对象存储到STL容器里，核心在于确保你的对象满足容器对元素类型的一些基本契约。这通常意味着你的自定义类型需要支持拷贝、移动、默认构造（某些情况）以及特定的比较操作（对于有序或无序容器）。选择直接存储对象值还是智能指针，取决于对象的生命周期、大小和多态性需求。

解决方案

将自定义对象放入STL容器，最直接的方式是确保它们具备“值语义”：可以被安全地拷贝和赋值。如果对象较大，或者涉及多态，那么使用智能指针来管理对象的生命周期会是更好的选择。

1. 值语义：直接存储对象

这是最简单也最常见的做法。你的自定义类

MyClass

登录后复制

需要满足以下条件：

立即学习“C++免费学习笔记（深入）”；

可拷贝构造（Copy Constructible）：容器在插入元素时可能会进行拷贝。
可拷贝赋值（Copy Assignable）：容器在重新分配或修改元素时可能会进行赋值。
可移动构造/赋值（Move Constructible/Assignable）：C++11及以后，这能显著提升性能，避免不必要的深拷贝。
默认构造（Default Constructible）：并非所有容器操作都要求，但像
```
std::vector<MyClass>(size)
```
登录后复制
这样的初始化就需要。

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>

// 示例自定义对象
class MyObject {
public:
    int id;
    std::string name;

    // 默认构造函数
    MyObject() : id(0), name("default") {
        // std::cout << "MyObject default constructed." << std::endl;
    }

    // 带参数构造函数
    MyObject(int i, const std::string& n) : id(i), name(n) {
        // std::cout << "MyObject(" << id << ", " << name << ") constructed." << std::endl;
    }

    // 拷贝构造函数 (如果包含动态资源，需自定义深拷贝)
    MyObject(const MyObject& other) : id(other.id), name(other.name) {
        // std::cout << "MyObject copied from " << other.id << "." << std::endl;
    }

    // 拷贝赋值运算符
    MyObject& operator=(const MyObject& other) {
        if (this != &other) {
            id = other.id;
            name = other.name;
        }
        // std::cout << "MyObject assigned from " << other.id << "." << std::endl;
        return *this;
    }

    // 移动构造函数 (C++11 以后推荐)
    MyObject(MyObject&& other) noexcept : id(other.id), name(std::move(other.name)) {
        other.id = 0; // 清空源对象
        // std::cout << "MyObject moved from " << other.id << "." << std::endl;
    }

    // 移动赋值运算符
    MyObject& operator=(MyObject&& other) noexcept {
        if (this != &other) {
            id = other.id;
            name = std::move(other.name);
            other.id = 0;
        }
        // std::cout << "MyObject move assigned from " << other.id << "." << std::endl;
        return *this;
    }

    // 析构函数
    ~MyObject() {
        // std::cout << "MyObject(" << id << ") destructed." << std::endl;
    }

    // 用于输出
    void print() const {
        std::cout << "ID: " << id << ", Name: " << name << std::endl;
    }

    // 用于有序容器的比较操作符
    bool operator<(const MyObject& other) const {
        return id < other.id;
    }

    // 用于无序容器的相等操作符
    bool operator==(const MyObject& other) const {
        return id == other.id && name == other.name;
    }
};

// 存储到std::vector
void store_in_vector_by_value() {
    std::vector<MyObject> objects;
    objects.emplace_back(1, "Alice"); // 推荐使用 emplace_back 避免额外拷贝
    objects.push_back(MyObject(2, "Bob")); // 会发生一次移动构造
    objects.push_back({3, "Charlie"}); // C++11 initializer list, 也会发生移动构造

    for (const auto& obj : objects) {
        obj.print();
    }
}

// 存储到std::map (需要 operator<)
void store_in_map_by_value() {
    std::map<MyObject, std::string> object_map; // MyObject 作为 key
    object_map.emplace(MyObject(10, "MapKey1"), "Value A");
    object_map.emplace(MyObject(5, "MapKey2"), "Value B");

    for (const auto& pair : object_map) {
        pair.first.print();
        std::cout << " -> " << pair.second << std::endl;
    }
}

登录后复制

2. 指针语义：存储智能指针

当对象很大、拷贝开销高昂、需要多态行为，或者需要共享所有权时，存储智能指针（

std::unique_ptr

登录后复制

或

std::shared_ptr

登录后复制

）是更好的选择。

#include <memory> // for std::unique_ptr, std::shared_ptr

// 存储到std::vector，使用unique_ptr
void store_in_vector_with_unique_ptr() {
    std::vector<std::unique_ptr<MyObject>> objects;
    objects.push_back(std::make_unique<MyObject>(101, "UniqueAlice"));
    objects.push_back(std::unique_ptr<MyObject>(new MyObject(102, "UniqueBob"))); // 不推荐直接new

    for (const auto& ptr : objects) {
        if (ptr) { // 检查指针是否有效
            ptr->print();
        }
    }
}

// 存储到std::vector，使用shared_ptr
void store_in_vector_with_shared_ptr() {
    std::vector<std::shared_ptr<MyObject>> objects;
    objects.push_back(std::make_shared<MyObject>(201, "SharedCharlie"));
    std::shared_ptr<MyObject> obj2 = std::make_shared<MyObject>(202, "SharedDavid");
    objects.push_back(obj2); // 共享所有权
    objects.push_back(obj2); // 再次共享

    for (const auto& ptr : objects) {
        if (ptr) {
            ptr->print();
        }
    }
    // 当vector被销毁，或者shared_ptr从vector中移除，引用计数会减少。
    // 当引用计数归零时，MyObject对象才会被真正销毁。
}

// 存储到std::map，使用shared_ptr作为值
void store_in_map_with_shared_ptr_value() {
    std::map<int, std::shared_ptr<MyObject>> object_map;
    object_map[1] = std::make_shared<MyObject>(301, "MapSharedObj1");
    object_map[2] = std::make_shared<MyObject>(302, "MapSharedObj2");

    for (const auto& pair : object_map) {
        std::cout << "Key: " << pair.first << ", ";
        pair.second->print();
    }
}

登录后复制

为什么我的自定义对象存不进去，或者行为异常？

这绝对是初学者，甚至是一些经验丰富的开发者也可能踩的坑。我遇到过不少类似的问题，通常是由于自定义对象未能满足STL容器的隐含要求。

缺少或错误的拷贝/移动操作符：如果你自定义了析构函数，或者类中包含原始指针等资源，编译器可能不会生成正确的默认拷贝/移动操作符。默认的浅拷贝会导致“双重释放”或数据损坏。比如，你有一个
```
char* name;
```
登录后复制
成员，默认拷贝只会复制指针地址，导致两个对象指向同一块内存，一个被删除后，另一个就成了悬空指针。正确的做法是实现深拷贝（为
```
name
```
登录后复制
成员分配新内存并复制内容）。
没有默认构造函数：像
```
std::vector<MyObject>(10);
```
登录后复制
这样的操作会尝试创建10个
```
MyObject
```
登录后复制
的实例，这时就需要
```
MyObject
```
登录后复制
有一个无参数的默认构造函数。如果你只提供了带参数的构造函数，就会编译失败。
有序容器（如
std::map
登录后复制
,
std::set
登录后复制
,
std::priority_queue
登录后复制
）缺少比较操作符：这些容器需要知道如何对元素进行排序。默认情况下，它们会查找
```
operator<
```
登录后复制
。如果你的
```
MyObject
```
登录后复制
没有定义
```
operator<
```
登录后复制
，或者定义得不正确（例如，没有满足严格弱序的要求），那么编译会失败，或者容器的行为会非常诡异，比如插入的元素不见了，或者查找失败。我记得有一次，调试一个
```
std::set
```
登录后复制
里的自定义对象，怎么都找不到元素，最后才发现
```
operator<
```
登录后复制
的实现只比较了部分字段，导致了逻辑错误。
无序容器（如
std::unordered_map
登录后复制
,
std::unordered_set
登录后复制
）缺少哈希函数和相等操作符：这些容器依赖哈希表工作，需要知道如何计算对象的哈希值 (
```
std::hash
```
登录后复制
) 以及如何判断两个对象是否相等 (
```
operator==
```
登录后复制
)。如果缺少这些，容器就无法正确存储和查找元素。
对象切片（Slicing Problem）：当你尝试将派生类对象以值的方式存储到基类对象的容器中时（例如
```
std::vector<Base> vec; vec.push_back(Derived());
```
登录后复制
），派生类特有的部分会被“切掉”，只剩下基类部分。这是因为容器存储的是
```
Base
```
登录后复制
类型的大小。解决办法通常是存储智能指针，如
```
std::vector<std::unique_ptr<Base>>
```
登录后复制
或
```
std::vector<std::shared_ptr<Base>>
```
登录后复制
，这样就能保持多态性。

什么时候该用值存储，什么时候该用智能指针？

这是一个关键的设计决策，没有绝对的答案，更多是权衡。

选择值存储（

std::vector<MyObject>

登录后复制

）的情况：

对象小巧且拷贝开销低：如果你的
```
MyObject
```
登录后复制
只是几个
```
int
```
登录后复制
或
```
std::string
```
登录后复制
组成，拷贝它并不会带来显著的性能问题。
明确的值语义：当拷贝一个对象意味着创建一个独立、完全相同的副本，并且这个副本可以独立存在和修改，而不会影响原对象时，值语义是合适的。比如
```
int
```
登录后复制
、
```
std::string
```
登录后复制
都是典型的有值语义的类型。
不需要多态行为：如果你不需要通过基类指针来操作派生类对象，那么直接存储值通常更简单。
所有权简单明确：容器拥有其内部元素的完整所有权，当容器被销毁时，其内部所有元素也会被销毁。
内存局部性可能更好：在
```
std::vector
```
登录后复制
等连续内存容器中，值存储的对象通常能带来更好的缓存局部性，访问速度可能更快。

选择智能指针存储（

std::vector<std::unique_ptr<MyObject>>

登录后复制

或
std::vector<std::shared_ptr<MyObject>>
登录后复制
）的情况：

AutoGLM沉思

智谱AI推出的具备深度研究和自主执行能力的AI智能体

129

查看详情

对象体积庞大或拷贝开销高：避免不必要的深拷贝是性能优化的重要手段。存储指针可以避免昂贵的拷贝操作。
需要多态行为：这是智能指针在容器中应用的一个主要场景。你可以存储
```
std::shared_ptr<BaseClass>
```
登录后复制
，但实际指向的是
```
DerivedClass
```
登录后复制
的实例，从而实现多态调用。
复杂的对象生命周期管理：
- 唯一所有权 (
  std::unique_ptr
  登录后复制
  )：当一个对象只能有一个所有者，并且所有权可以转移时。容器拥有对象的唯一所有权，当元素从容器中移除或容器销毁时，对象会被销毁。
- 共享所有权 (
  std::shared_ptr
  登录后复制
  )：当多个部分需要共同拥有一个对象，并在所有所有者都放弃所有权时才销毁对象。例如，一个对象可能被容器持有，同时也被某个回调函数捕获。
对象不能被拷贝：有些对象（如
```
std::mutex
```
登录后复制
,
```
std::thread
```
登录后复制
）是不可拷贝的，但它们可以被移动。在这种情况下，
```
std::unique_ptr
```
登录后复制
是一个很好的选择，因为它支持移动语义。
动态创建的对象：当你需要
```
new
```
登录后复制
一个对象时，使用智能指针可以确保即使在异常情况下也能正确
```
delete
```
登录后复制
掉对象，避免内存泄漏。

我的个人建议是： 优先考虑值语义，除非有明确的理由（如上述的性能、多态、复杂所有权）选择智能指针。值语义代码通常更直观、更易于理解和调试。

如何为自定义对象实现哈希和相等性比较？

当你想把自定义对象放到

std::unordered_map

登录后复制

或

std::unordered_set

登录后复制

这种无序容器里时，就必须告诉C++如何计算这个对象的哈希值，以及如何判断两个对象是否相等。

1. 实现

operator==

登录后复制

(相等性比较)

这是基础，因为哈希冲突时，容器会用

operator==

登录后复制

来判断两个键是否真的相同。

class MyUnorderedObject {
public:
    int x;
    int y;
    std::string label;

    MyUnorderedObject(int _x, int _y, const std::string& _label) : x(_x), y(_y), label(_label) {}

    // 成员函数形式的 operator==
    bool operator==(const MyUnorderedObject& other) const {
        return (x == other.x && y == other.y && label == other.label);
    }
};

// 也可以是友元函数或普通非成员函数
// bool operator==(const MyUnorderedObject& lhs, const MyUnorderedObject& rhs) {
//     return (lhs.x == rhs.x && lhs.y == rhs.y && lhs.label == rhs.label);
// }

登录后复制

注意： 如果你只定义了

operator==

登录后复制

而没有定义

operator!=

登录后复制

，编译器通常会为你生成一个默认的

operator!=

登录后复制

，它会调用

operator==

登录后复制

并取反。但显式定义通常更清晰。

2. 实现哈希函数

有两种主要方法：特化

std::hash

登录后复制

或者提供一个自定义的哈希函数对象。

方法一：特化

std::hash

登录后复制

(推荐)

这是最C++标准库风格的做法，使得你的

MyUnorderedObject

登录后复制

可以直接与

std::unordered_map

登录后复制

和

std::unordered_set

登录后复制

一起使用，而无需额外的模板参数。

#include <functional> // for std::hash

// 在 MyUnorderedObject 定义之后，但在使用它作为无序容器的键之前
namespace std {
    template <> // 特化 std::hash 模板
    struct hash<MyUnorderedObject> {
        // 哈希函数调用操作符
        std::size_t operator()(const MyUnorderedObject& obj) const {
            // 这是一个简单的哈希组合策略。
            // 实际应用中，可以考虑使用 Boost.Hash 或更复杂的算法。
            // 这里我们使用 std::hash 对每个成员进行哈希，然后组合它们。
            std::size_t h1 = std::hash<int>()(obj.x);
            std::size_t h2 = std::hash<int>()(obj.y);
            std::size_t h3 = std::hash<std::string>()(obj.label);

            // 组合哈希值的常见方法：
            // 每次组合一个新值时，将当前哈希值左移一位（或异或一个常数），然后与新值的哈希值异或。
            // 这种方法避免了简单的相加可能导致的哈希冲突。
            std::size_t seed = 0;
            // 模拟 Boost.Hash 的 hash_combine
            seed ^= h1 + 0x9e3779b

登录后复制

以上就是C++如何使用STL容器存储自定义对象的详细内容，更多请关注php中文网其它相关文章！