C++如何在复合对象中使用智能指针

使用智能指针管理复合对象内存，可防止泄漏。选择unique_ptr实现独占所有权，shared_ptr实现共享所有权，weak_ptr打破循环引用。通过make_unique和make_shared安全初始化，避免shared_ptr循环引用导致内存泄漏。在多线程环境中，shared_ptr引用计数线程安全，但对象访问需加锁，unique_ptr不可共享，可用原子操作或互斥锁保护共享数据。示例展示了组件模式中unique_ptr管理子对象及weak_ptr解决循环引用问题。

C++中在复合对象中使用智能指针，是为了更好地管理内存，防止内存泄漏。核心在于确保当复合对象销毁时，其拥有的子对象的内存也能被正确释放。使用智能指针，特别是

std::unique_ptr

std::shared_ptr

解决方案

在复合对象中使用智能指针，通常涉及以下几个关键点：

1. 选择合适的智能指针类型：

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

   • std::unique_ptr

     ： 当复合对象对子对象拥有独占所有权时，使用

     std::unique_ptr

     。这意味着只有一个智能指针可以指向该子对象。当

     unique_ptr

     离开作用域时，它会自动删除所指向的对象。

   • std::shared_ptr

     ： 当多个对象需要共享对子对象的所有权时，使用

     std::shared_ptr

     。

     shared_ptr

     使用引用计数来跟踪有多少个

     shared_ptr

     指向同一个对象。当最后一个

     shared_ptr

     离开作用域时，才会删除所指向的对象。

   • std::weak_ptr

     ：

     weak_ptr

     是一种不拥有所有权的智能指针，通常与

     shared_ptr

     一起使用。它可以用来观察

     shared_ptr

     所指向的对象，而不会增加引用计数。这可以避免循环引用导致内存泄漏。

2. 初始化智能指针：

   • 使用

     std::make_unique

     创建

     unique_ptr

     ，它可以防止异常安全问题。
   • 使用

     std::make_shared

     创建

     shared_ptr

     ，同样是为了异常安全。

3. 避免循环引用（对于

   shared_ptr

   ）：
   

   英特尔AI工具

   英特尔AI与机器学习解决方案

   下载
   • 当两个或多个对象互相持有

     shared_ptr

     时，可能形成循环引用，导致内存泄漏。使用

     weak_ptr

     可以打破这种循环。

4. 使用智能指针管理容器中的对象：

   • 当复合对象包含一个容器（如

     std::vector

     或

     std::list

     ），并且容器中的元素是指向子对象的指针时，可以使用智能指针来管理这些子对象。

示例代码

#include 
#include 
#include 

class Component {
public:
    virtual void operation() = 0;
    virtual ~Component() = default;
};

class ConcreteComponentA : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponentA operation\n";
    }
};

class ConcreteComponentB : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponentB operation\n";
    }
};

class Composite {
private:
    std::vector> children;

public:
    void add(std::unique_ptr child) {
        children.push_back(std::move(child));
    }

    void operation() {
        for (const auto& child : children) {
            child->operation();
        }
    }
};

int main() {
    Composite composite;
    composite.add(std::make_unique());
    composite.add(std::make_unique());
    composite.operation(); // 输出 ConcreteComponentA operation 和 ConcreteComponentB operation
    return 0;
}

如何选择

unique_ptr

、

shared_ptr

和

weak_ptr

？

选择哪种智能指针取决于对象的所有权模型。

• unique_ptr

  ： 适用于对象的所有权是独占的，即只有一个所有者。例如，一个类的成员变量，该类负责管理该成员的生命周期。

• shared_ptr

  ： 适用于多个对象需要共享所有权的情况。例如，多个对象需要访问同一个资源，并且该资源需要在所有对象都不再需要时才被释放。

• weak_ptr

  ： 适用于需要观察

  shared_ptr

  所指向的对象，但不希望拥有所有权的情况。例如，缓存，当缓存中的对象不再被其他对象使用时，应该被释放。

如何避免循环引用导致的内存泄漏？

循环引用发生在两个或多个对象互相持有

shared_ptr

解决循环引用的方法是使用

weak_ptr

weak_ptr

#include 
#include 

class B; // 前向声明

class A {
public:
    std::shared_ptr b_ptr;
    ~A() { std::cout << "A is destroyed\n"; }
};

class B {
public:
    std::weak_ptr a_ptr; // 使用 weak_ptr 打破循环引用
    ~B() { std::cout << "B is destroyed\n"; }
};

int main() {
    std::shared_ptr a = std::make_shared();
    std::shared_ptr b = std::make_shared();

    a->b_ptr = b;
    b->a_ptr = a;

    return 0; // A 和 B 对象都会被正确销毁
}

智能指针在多线程环境下的使用需要注意什么？

#include 
#include 
#include 
#include 

std::mutex mtx;
std::shared_ptr shared_data;

void thread_function() {
    std::lock_guard lock(mtx); // 保护共享数据
    if (shared_data) {
        std::cout << "Thread: " << *shared_data << std::endl;
    }
}

int main() {
    shared_data = std::make_shared(42);

    std::thread t1(thread_function);
    std::thread t2(thread_function);

    t1.join();
    t2.join();

    return 0;
}