C++如何使用智能指针管理动态分配对象-C++-PHP中文网

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

P粉602998670

发布： 2025-09-09 12:24:02

原创

830人浏览过

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

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 <iostream>
#include <memory>

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<MyClass> ptr1 = std::make_shared<MyClass>(10);
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl; // 输出 1

    // 复制 shared_ptr
    std::shared_ptr<MyClass> 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 <iostream>
#include <memory>

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<Resource> ptr1 = std::make_unique<Resource>("File.txt");

    // 所有权转移：ptr1 的所有权转移到 ptr2
    std::unique_ptr<Resource> 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。

使用限制:

如此AI写作

AI驱动的内容营销平台，提供一站式的AI智能写作、管理和分发数字化工具。

137

查看详情

不能复制unique_ptr。这是因为unique_ptr的设计目标是确保只有一个指针指向对象。如果允许复制unique_ptr，就会违反这个原则。
unique_ptr可以用于指向数组。可以使用
```
std::unique_ptr<int[]>
```
登录后复制
来管理动态分配的数组。

weak_ptr 如何解决循环引用问题

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

#include <iostream>
#include <memory>

class B; // 前向声明

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

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

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

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

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

登录后复制

如何解决循环引用:

在一个类中使用weak_ptr指向另一个类，从而打破循环引用。例如，A对象包含一个指向B对象的shared_ptr，而B对象包含一个指向A对象的weak_ptr。在这种情况下，当A和B对象不再被使用时，它们的引用计数最终会降为0，从而避免内存泄漏。
在使用weak_ptr之前，需要先使用
```
lock()
```
登录后复制
方法将其转换为shared_ptr。如果对象已经被销毁，
```
lock()
```
登录后复制
方法将返回一个空的shared_ptr。

何时应该避免使用智能指针

尽管智能指针提供了许多好处，但在某些情况下，使用原始指针可能更合适。

性能关键型代码: 智能指针会带来一些性能开销，例如引用计数的维护和内存分配。在性能至关重要的代码中，可以考虑使用原始指针来避免这些开销。但是，需要仔细管理原始指针的生命周期，以避免内存泄漏和悬挂指针。
与C代码的互操作: C代码通常不使用智能指针。如果需要将C++代码与C代码进行互操作，可能需要使用原始指针。
嵌入式系统: 在资源受限的嵌入式系统中，智能指针的内存开销可能是一个问题。在这种情况下，可以使用原始指针或自定义的内存管理方案。

如何自定义删除器来管理特殊资源

智能指针可以使用自定义删除器来管理特殊资源，例如文件句柄或网络连接。

#include <iostream>
#include <memory>
#include <fstream>

// 自定义删除器，用于关闭文件
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<std::ofstream> 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;
}

登录后复制

如何使用自定义删除器: