C++智能指针有哪些基本类型 解析unique_ptr shared_ptr weak_ptr核心区别

#include <memory>
#include <iostream>

class MyResource {
public:
    MyResource(int id) : id_(id) {
        std::cout << "MyResource " << id_ << " created." << std::endl;
    }
    ~MyResource() {
        std::cout << "MyResource " << id_ << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyResource " << id_ << " doing something." << std::endl;
    }
private:
    int id_;
};

// 假设一个函数返回一个unique_ptr
std::unique_ptr<MyResource> createResource(int id) {
    return std::make_unique<MyResource>(id); // 返回一个unique_ptr
}

int main() {
    std::unique_ptr<MyResource> ptr1 = std::make_unique<MyResource>(1);
    ptr1->doSomething();

    // 移动所有权
    std::unique_ptr<MyResource> ptr2 = std::move(ptr1); 
    if (!ptr1) { // ptr1现在是空的
        std::cout << "ptr1 is now null." << std::endl;
    }
    ptr2->doSomething();

    // 函数返回的unique_ptr
    std::unique_ptr<MyResource> ptr3 = createResource(3);
    ptr3->doSomething();

    // unique_ptr也可以管理数组
    std::unique_ptr<int[]> arrPtr = std::make_unique<int[]>(5);
    arrPtr[0] = 10;
    std::cout << "arrPtr[0]: " << arrPtr[0] << std::endl;

    // 当unique_ptr离开作用域时，资源自动释放
    return 0; 
}

#include <memory>
#include <iostream>

class DataObject {
public:
    DataObject(const std::string& name) : name_(name) {
        std::cout << "DataObject " << name_ << " created." << std::endl;
    }
    ~DataObject() {
        std::cout << "DataObject " << name_ << " destroyed." << std::endl;
    }
    void showName() {
        std::cout << "My name is " << name_ << std::endl;
    }
private:
    std::string name_;
};

int main() {
    std::shared_ptr<DataObject> s_ptr1 = std::make_shared<DataObject>("SharedData");
    std::cout << "s_ptr1 use_count: " << s_ptr1.use_count() << std::endl;

    {
        std::shared_ptr<DataObject> s_ptr2 = s_ptr1; // 复制，增加引用计数
        std::cout << "s_ptr1 use_count: " << s_ptr1.use_count() << std::endl;
        s_ptr2->showName();
    } // s_ptr2 离开作用域，引用计数减少

    std::cout << "s_ptr1 use_count after s_ptr2 scope: " << s_ptr1.use_count() << std::endl;

    // 当所有shared_ptr都失效时，DataObject才会被销毁
    return 0;
}

#include <memory>
#include <iostream>
#include <string>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // 强引用
    std::string name;

    A(const std::string& n) : name(n) {
        std::cout << "A " << name << " created." << std::endl;
    }
    ~A() {
        std::cout << "A " << name << " destroyed." << std::endl;
    }
};

class B {
public:
    // 方案一：使用shared_ptr，会造成循环引用
    // std::shared_ptr<A> a_ptr; 

    // 方案二：使用weak_ptr，打破循环引用
    std::weak_ptr<A> a_ptr; // 弱引用

    std::string name;

    B(const std::string& n) : name(n) {
        std::cout << "B " << name << " created." << std.endl;
    }
    ~B() {
        std::cout << "B " << name << " destroyed." << std::endl;
    }
    void showAPtr() {
        if (auto sp = a_ptr.lock()) { // 尝试获取shared_ptr
            std::cout << "B " << name << " sees A " << sp->name << std::endl;
        } else {
            std::cout << "B " << name << " cannot see A (A has been destroyed)." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- 场景一：模拟循环引用 (如果B使用shared_ptr<A>) ---" << std::endl;
    // 如果B::a_ptr是shared_ptr，这里A和B都不会被销毁
    // {
    //     std::shared_ptr<A> a = std::make_shared<A>("ObjA");
    //     std::shared_ptr<B> b = std::make_shared<B>("ObjB");
    //     a->b_ptr = b;
    //     b->a_ptr = a; // 循环引用形成
    // } // A和B的引用计数永远不会降到0，导致内存泄漏
    // std::cout << "A and B should have been destroyed, but might not be due to circular reference." << std::endl;

    std::cout << "\n--- 场景二：使用weak_ptr解决循环引用 ---" << std::endl;
    {
        std::shared_ptr<A> a = std::make_shared<A>("ObjA_Weak");
        std::shared_ptr<B> b = std::make_shared<B>("ObjB_Weak");

        a->b_ptr = b;       // A强引用B
        b->a_ptr = a;       // B弱引用A

        std::cout << "A use_count: " << a.use_count() << std::endl; // 1 (来自a) + 1 (来自b_ptr) = 2
        std::cout << "B use_count: " << b.use_count() << std::endl; // 1 (来自b) + 1 (来自a_ptr) = 2 (这里是错误的，a->b_ptr是强引用，a->b_ptr会增加b的引用计数，但是b->a_ptr是弱引用，不会增加a的引用计数)
        // 修正：A use_count: 1 (来自a)
        // B use_count: 1 (来自b) + 1 (来自a->b_ptr) = 2

        std::cout << "A use_count (after assignment): " << a.use_count() << std::endl;
        std::cout << "B use_count (after assignment): " << b.use_count() << std::endl;


        b->showAPtr(); // B可以访问A
    } // a 和 b 离开作用域，引用计数降为0，A和B都被销毁
    std::cout << "A and B should be destroyed now." << std::endl;

    std::cout << "\n--- 场景三：weak_ptr作为观察者 ---" << std::endl;
    std::shared_ptr<DataObject> data = std::make_shared<DataObject>("ObservedData");
    std::weak_ptr<DataObject> observer = data;

    if (auto sp = observer.lock()) {
        std::cout << "Observer can still see: ";
        sp->showName();
    } else {
        std::cout << "Observer cannot see data." << std::endl;
    }

    data.reset(); // 销毁data指向的对象

    if (auto sp = observer.lock()) {
        std::cout << "Observer can still see: ";
        sp->showName();
    } else {
        std::cout << "Observer cannot see data (it's gone)." << std::endl;
    }

    return 0;
}