C++怎么使用智能指针 C++智能指针的类型与使用场景

c++++智能指针通过raii机制自动管理内存，避免内存泄漏。1. unique_ptr实现独占式所有权，确保同一时间只有一个指针指向对象，支持显式转移所有权，适用于资源管理和工厂函数返回值；2. shared_ptr采用引用计数实现共享所有权，最后一个shared_ptr销毁时释放对象，适合多指针共享资源的场景，并可结合weak_ptr解决循环引用；3. weak_ptr提供弱引用，不增加引用计数，用于观察对象状态或打破shared_ptr间的循环引用；4. 推荐使用make_shared创建shared_ptr，提升异常安全性和性能；5. 多线程环境下shared_ptr线程安全但对象访问需同步，unique_ptr非线程安全；6. 自定义删除器可用于释放非内存资源或执行特定清理操作；7. 选择智能指针时需权衡所有权模型、性能及线程安全等因素，慎用与原始指针的交互以避免重复释放或悬挂指针问题。

C++智能指针本质上是为了更好地管理动态分配的内存，避免内存泄漏。它们通过RAII（Resource Acquisition Is Initialization）机制，在对象生命周期结束时自动释放资源。

unique_ptr、shared_ptr、weak_ptr

unique_ptr

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

unique_ptr是独占式指针，意味着同一时间只能有一个unique_ptr指向特定的对象。它非常轻量级，开销几乎与原始指针相同，而且保证了对象所有权的唯一性。

#include 
#include 

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destructed\n"; }
    void doSomething() { std::cout << "Doing something...\n"; }
};

int main() {
    std::unique_ptr ptr(new MyClass()); // 创建 unique_ptr
    ptr->doSomething(); // 使用 -> 访问对象成员

    // std::unique_ptr ptr2 = ptr; // 错误！不能复制 unique_ptr

    std::unique_ptr ptr2 = std::move(ptr); // 正确，转移所有权
    if (ptr) {
        ptr->doSomething(); // 不会执行，因为 ptr 已经为空
    }
    if (ptr2) {
        ptr2->doSomething(); // ptr2 现在拥有对象
    }

    return 0; // ptr2 析构，MyClass 对象被销毁
}

unique_ptr的主要用途：

• 资源管理： 确保动态分配的对象在不再需要时被自动释放。
• 所有权转移： 通过std::move显式地转移所有权。
• 工厂函数： 用于从工厂函数返回动态分配的对象。

shared_ptr

shared_ptr允许多个指针指向同一个对象，它使用引用计数来跟踪有多少个shared_ptr指向该对象。当最后一个shared_ptr被销毁时，对象才会被释放。

#include 
#include 

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destructed\n"; }
    void doSomething() { std::cout << "Doing something...\n"; }
};

int main() {
    std::shared_ptr ptr1 = std::make_shared(); // 推荐使用 make_shared
    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->doSomething();
    ptr2->doSomething();

    ptr1.reset(); // 释放 ptr1 的所有权

    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl; // 输出 0
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl; // 输出 1

    return 0; // ptr2 析构，MyClass 对象被销毁
}

shared_ptr的主要用途：

• 共享所有权： 当多个对象需要共享对一个资源的所有权时。
• 循环引用处理： 与weak_ptr结合使用，打破循环引用。
• 并发编程： 在多线程环境中安全地共享资源。

weak_ptr

weak_ptr是一种弱引用，它指向由shared_ptr管理的对象，但不增加引用计数。weak_ptr不能直接访问对象，必须先转换为shared_ptr才能使用。当shared_ptr管理的对象被销毁时，weak_ptr会自动失效。

#include 
#include 

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destructed\n"; }
    void doSomething() { std::cout << "Doing something...\n"; }
};

int main() {
    std::shared_ptr sharedPtr = std::make_shared();
    std::weak_ptr weakPtr = sharedPtr;

    if (auto ptr = weakPtr.lock()) { // 尝试获取 shared_ptr
        ptr->doSomething(); // 安全地访问对象
        std::cout << "Object is still alive\n";
    } else {
        std::cout << "Object has been destroyed\n";
    }

    sharedPtr.reset(); // 释放 shared_ptr 的所有权

    if (auto ptr = weakPtr.lock()) {
        ptr->doSomething(); // 不会执行
        std::cout << "Object is still alive\n";
    } else {
        std::cout << "Object has been destroyed\n"; // 输出此行
    }

    return 0;
}

weak_ptr的主要用途：

• 观察者模式： 允许观察对象的状态，而不会影响对象的生命周期。
• 缓存： 缓存对象，当对象不再被使用时自动释放。
• 打破循环引用： 解决shared_ptr可能导致的循环引用问题。

如何选择合适的智能指针？

在选择智能指针时，需要考虑以下因素：

• 所有权模型： 是否需要独占所有权还是共享所有权？
• 性能： unique_ptr开销最小，shared_ptr开销较大。
• 线程安全： shared_ptr是线程安全的，unique_ptr不是。
• 循环引用： 是否需要处理循环引用问题？

为什么推荐使用make_shared？

std::make_shared是一个模板函数，用于创建一个shared_ptr并初始化其指向的对象。与先new再用shared_ptr包装相比，make_shared的主要优势在于：

• 异常安全： 如果new操作成功，但在shared_ptr构造函数中抛出异常，会导致内存泄漏。make_shared将对象的内存分配和shared_ptr的构造放在一起，避免了这个问题。
• 性能优化： make_shared通常会一次性分配对象和shared_ptr控制块的内存，减少内存分配次数，提高性能。

智能指针与原始指针的混合使用问题

虽然智能指针旨在替代原始指针，但在某些情况下，仍然需要与原始指针交互，例如：

ModelGate

一站式AI模型管理与调用工具

下载

• 与旧代码库集成： 旧代码库可能使用原始指针，需要将智能指针转换为原始指针进行交互。
• 底层操作： 某些底层操作可能需要直接访问内存地址。

在与原始指针交互时，需要格外小心，避免出现以下问题：

• 重复释放： 不要使用原始指针delete由智能指针管理的对象。
• 悬挂指针： 当智能指针释放对象后，原始指针可能变成悬挂指针。

可以使用get()方法从智能指针获取原始指针，但必须谨慎使用，并确保在使用原始指针时，智能指针仍然有效。

如何避免循环引用？

循环引用是指两个或多个对象相互持有shared_ptr，导致引用计数永远不为零，对象无法被释放。

例如：

#include 
#include 

class A; // 前向声明

class B {
public:
    std::shared_ptr a;
    ~B() { std::cout << "B destructed\n"; }
};

class A {
public:
    std::shared_ptr b;
    ~A() { std::cout << "A destructed\n"; }
};

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

    a->b = b;
    b->a = a; // 循环引用

    // a 和 b 都不会被销毁，导致内存泄漏

    return 0;
}

解决循环引用的常用方法是使用weak_ptr。将其中一个shared_ptr改为weak_ptr，打破循环引用。

#include 
#include 

class A; // 前向声明

class B {
public:
    std::weak_ptr a; // 使用 weak_ptr
    ~B() { std::cout << "B destructed\n"; }
};

class A {
public:
    std::shared_ptr b;
    ~A() { std::cout << "A destructed\n"; }
};

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

    a->b = b;
    b->a = a; // 循环引用被打破

    // a 和 b 都会被销毁

    return 0;
}

智能指针在多线程环境下的使用

#include 
#include 

void customDeleter(int* ptr) {
    std::cout << "Custom deleter called\n";
    delete ptr;
}

int main() {
    std::unique_ptr ptr(new int(10), customDeleter);

    // 或者使用 lambda 表达式
    std::shared_ptr sharedPtr(new int(20), [](int* ptr) {
        std::cout << "Lambda deleter called\n";
        delete ptr;
    });

    return 0;
}