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

wufei123 发布于 2025-09-11 阅读（13）
智能指针通过自动管理内存防止泄漏，主要包括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;
}

注意事项:

  • 循环引用: 避免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。

使用限制:

PIA PIA

全面的AI聚合平台，一站式访问所有顶级AI模型

PIA226 查看详情 PIA
  • 不能复制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;
}

如何使用自定义删除器:

  • 可以向智能指针的构造函数传递一个自定义删除器。删除器可以是函数对象、lambda表达式或函数指针。
  • 当智能指针被销毁时，删除器会被调用，用于释放智能指针所管理的资源。

智能指针是C++中管理动态分配对象的重要工具。理解不同类型智能指针的特性和使用场景，可以帮助你编写更安全、更高效的代码。

以上就是C++如何使用智能指针管理动态分配对象的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： c++ 工具 ai ios 作用域 标准库 red NULL 构造函数 int 循环 Lambda 指针 指针类型 线程 对象 数据库 嵌入式系统 大家都在看： C++如何使用模板实现迭代器类 C++如何处理复合对象中的嵌套元素 C++内存模型与编译器优化理解 C++如何使用ofstream和ifstream组合操作文件 C++循环与算法优化提高程序执行效率

标签:  指针 如何使用 对象 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表