C++STL容器与智能指针结合使用

智能指针与STL容器结合主要用于自动管理动态对象的生命周期，常见场景包括：1. 使用std::vector管理独占所有权的对象集合，避免内存泄漏；2. 在树或图等复杂数据结构中，用std::shared_ptr实现共享节点，简化内存管理；3. 多线程环境下通过std::shared_ptr安全共享资源，防止悬挂指针。std::unique_ptr适用于单一所有者，不可复制但可转移；std::shared_ptr支持多所有者，但需警惕循环引用。为避免循环引用，应使用std::weak_ptr打破强引用环，如父子节点关系中子节点持有父节点的std::weak_ptr。除这两个外，标准库还提供std::weak_ptr，而Boost等库有扩展智能指针，但推荐优先使用标准智能指针以保证兼容性。

C++ STL容器和智能指针结合使用，主要是为了解决内存管理问题，避免手动

new/delete

使用STL容器存储智能指针，可以确保当容器销毁或者元素被移除时，智能指针会自动释放其所指向的内存。这避免了内存泄漏，也简化了代码。

智能指针与STL容器结合，有哪些常见应用场景？

管理动态分配的对象集合

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

假设你需要维护一个动态分配的对象集合，比如一系列自定义类的实例。使用

std::vector>

#include 
#include 
#include 

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass created with value: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destroyed with value: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    std::vector> myObjects;
    myObjects.push_back(std::make_unique(10));
    myObjects.push_back(std::make_unique(20));

    for (const auto& obj : myObjects) {
        std::cout << "Value: " << obj->getValue() << std::endl;
    }

    // 当 myObjects 销毁时，其中包含的 MyClass 对象也会自动被销毁
    return 0;
}

在这个例子中，

std::unique_ptr

MyClass

myObjects

MyClass

实现复杂数据结构

某些数据结构，例如树或者图，通常需要动态分配节点。使用智能指针可以简化节点的内存管理。例如，你可以使用

std::shared_ptr

避免悬挂指针

当多个对象需要共享同一个资源时，使用

std::shared_ptr

std::shared_ptr

使用

std::unique_ptr

std::shared_ptr

std::unique_ptr

std::unique_ptr

std::unique_ptr

std::move

LobeHub

LobeChat brings you the best user experience of ChatGPT, OLLaMA, Gemini, Claude

下载

std::shared_ptr

std::shared_ptr

std::shared_ptr

选择哪个取决于你的需求。如果只有一个所有者，使用

std::unique_ptr

std::shared_ptr

std::shared_ptr

如何避免在使用

std::shared_ptr

循环引用是指两个或多个对象互相持有对方的

std::shared_ptr

避免循环引用的一种方法是使用

std::weak_ptr

std::weak_ptr

std::weak_ptr

例如，考虑一个父子关系的场景：

#include 
#include 

class Child; // 前向声明

class Parent {
public:
    std::shared_ptr child;
    ~Parent() { std::cout << "Parent destroyed" << std::endl; }
};

class Child {
public:
    std::shared_ptr parent; // 如果这里用 shared_ptr，就会造成循环引用
    ~Child() { std::cout << "Child destroyed" << std::endl; }
};

int main() {
    std::shared_ptr parent = std::make_shared();
    std::shared_ptr child = std::make_shared();

    parent->child = child;
    child->parent = parent; // 循环引用

    // parent 和 child 都不会被销毁，导致内存泄漏
    return 0;
}

为了解决这个问题，可以将

Child

parent

std::weak_ptr

#include 
#include 

class Child; // 前向声明

class Parent {
public:
    std::shared_ptr child;
    ~Parent() { std::cout << "Parent destroyed" << std::endl; }
};

class Child {
public:
    std::weak_ptr parent; // 使用 weak_ptr 打破循环引用
    ~Child() { std::cout << "Child destroyed" << std::endl; }
};

int main() {
    std::shared_ptr parent = std::make_shared();
    std::shared_ptr child = std::make_shared();

    parent->child = child;
    child->parent = parent; // 不再造成循环引用

    // parent 和 child 都会被正确销毁
    return 0;
}

现在，

Child

parent

parent

Child

除了

std::unique_ptr

std::shared_ptr

除了

std::unique_ptr

std::shared_ptr

std::weak_ptr

std::shared_ptr

此外，还有一些非标准的智能指针，例如boost库中的智能指针，它们提供了更多的功能和选项，例如

scoped_ptr

std::unique_ptr

intrusive_ptr