C++如何使用智能指针管理动态分配对象

智能指针通过自动管理内存防止泄漏，主要包括shared_ptr、unique_ptr和weak_ptr；shared_ptr用于共享所有权并自动释放资源，但需避免循环引用；unique_ptr确保独占所有权，支持所有权转移但不可复制；weak_ptr用于打破循环引用，观察shared_ptr管理的对象；在性能敏感、与C互操作或嵌入式场景中可考虑原始指针；还可通过自定义删除器管理特殊资源如文件句柄。

智能指针本质上是为了更安全地管理C++中的动态内存分配。它们通过自动释放不再需要的内存来防止内存泄漏，并简化了资源管理。

shared_ptr、unique_ptr和weak_ptr是C++标准库提供的三种主要智能指针类型，每种类型都有不同的用途和所有权模型。

shared_ptr：允许多个指针指向同一个对象，并使用引用计数来跟踪有多少个shared_ptr指向该对象。当最后一个shared_ptr被销毁时，对象会被自动删除。 unique_ptr：提供对对象的独占所有权。一次只能有一个unique_ptr指向一个对象，当unique_ptr被销毁时，对象会被自动删除。 weak_ptr：不增加对象的引用计数，而是提供对shared_ptr所管理对象的非拥有访问。weak_ptr可以用来检测对象是否仍然存在。

shared_ptr 的使用场景和注意事项

shared_ptr适用于多个对象需要共享同一个资源的情况。例如，多个对象需要访问同一个数据库连接或同一个文件句柄。

#include 
#include 

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass constructor, value: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor, value: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    // 创建一个 shared_ptr 指向 MyClass 对象
    std::shared_ptr ptr1 = std::make_shared(10);
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl; // 输出 1

    // 复制 shared_ptr
    std::shared_ptr ptr2 = ptr1;
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl; // 输出 2
    std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl; // 输出 2

    // ptr1 和 ptr2 指向同一个对象
    std::cout << "ptr1 value: " << ptr1->getValue() << std::endl;
    std::cout << "ptr2 value: " << ptr2->getValue() << std::endl;

    // 当 ptr1 和 ptr2 都超出作用域时，MyClass 对象才会被销毁
    return 0;
}

注意事项:

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

• 循环引用: 避免shared_ptr的循环引用，否则会导致内存泄漏。例如，A对象包含一个指向B对象的shared_ptr，而B对象又包含一个指向A对象的shared_ptr。在这种情况下，即使A和B对象不再被使用，它们的引用计数也永远不会降为0，导致内存泄漏。可以使用weak_ptr来打破循环引用。
• 线程安全: shared_ptr的引用计数是线程安全的，但是shared_ptr所管理的对象本身不一定是线程安全的。如果多个线程同时访问shared_ptr所管理的对象，需要进行适当的同步。

• make_shared

  vs

  new

  : 优先使用

  std::make_shared

  创建

  shared_ptr

  。

  make_shared

  可以一次性分配对象和控制块（用于引用计数），从而提高效率并避免潜在的异常安全问题。

unique_ptr 的所有权转移和使用限制

unique_ptr适用于需要确保只有一个指针指向对象的情况。例如，表示文件句柄或网络连接等独占资源。

#include 
#include 

class Resource {
public:
    Resource(std::string name) : name_(name) {
        std::cout << "Resource " << name_ << " acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource " << name_ << " released." << std::endl;
    }

    std::string getName() const { return name_; }

private:
    std::string name_;
};

int main() {
    // 创建一个 unique_ptr 指向 Resource 对象
    std::unique_ptr ptr1 = std::make_unique("File.txt");

    // 所有权转移：ptr1 的所有权转移到 ptr2
    std::unique_ptr ptr2 = std::move(ptr1);

    // ptr1 现在为空
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is now null." << std::endl;
    }

    // ptr2 拥有 Resource 对象
    std::cout << "ptr2 owns resource: " << ptr2->getName() << std::endl;

    // 当 ptr2 超出作用域时，Resource 对象会被自动释放
    return 0;
}

所有权转移:

• unique_ptr可以通过

  std::move

  函数将所有权转移给另一个unique_ptr。转移后，原来的unique_ptr将变为null。

使用限制:

SlidesAI

使用SlidesAI的AI在几秒钟内创建演示文稿幻灯片

下载

• 不能复制unique_ptr。这是因为unique_ptr的设计目标是确保只有一个指针指向对象。如果允许复制unique_ptr，就会违反这个原则。
• unique_ptr可以用于指向数组。可以使用

  std::unique_ptr

  来管理动态分配的数组。

weak_ptr 如何解决循环引用问题

weak_ptr用于观察shared_ptr所管理的对象，但不增加对象的引用计数。它可以用来检测对象是否仍然存在，并避免循环引用。

#include 
#include 

class B; // 前向声明

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

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

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

    a->b_ptr = b;
    b->a_ptr = a; // b 观察 a，但不拥有 a

    // 当 a 和 b 超出作用域时，它们都会被销毁，不会发生内存泄漏
    return 0;
}

如何解决循环引用:

#include 
#include 
#include 

// 自定义删除器，用于关闭文件
struct FileDeleter {
    void operator()(std::ofstream* file) {
        if (file->is_open()) {
            file->close();
            std::cout << "File closed." << std::endl;
        }
        delete file;
    }
};

int main() {
    // 创建一个 shared_ptr，并使用自定义删除器
    std::shared_ptr file(new std::ofstream("example.txt"), FileDeleter());

    // 检查文件是否成功打开
    if (file->is_open()) {
        *file << "Hello, world!" << std::endl;
    } else {
        std::cerr << "Unable to open file." << std::endl;
    }

    // 当 file 超出作用域时，FileDeleter 会被调用，文件会被关闭
    return 0;
}