C++各种智能指针的使用小结

#include <memory>
#include <iostream>

int main() {
    // 1. 创建：优先用make_unique（C++14引入，更安全高效）
    std::unique_ptr<int> p1 = std::make_unique<int>(42); 
    // 等价于：std::unique_ptr<int> p1(new int(42));

    // 2. 访问对象：用*或->
    std::cout << *p1 << std::endl; // 输出42

    // 3. 移动所有权（不可拷贝）
    std::unique_ptr<int> p2 = std::move(p1); // p1失去所有权，变为nullptr
    if (!p1) std::cout << "p1 is null" << std::endl;

    // 4. 数组版本
    std::unique_ptr<int[]> arr = std::make_unique<int[]>(3);
    arr[0] = 1; arr[1] = 2; arr[2] = 3;

    // 5. 释放所有权：release()返回裸指针，不再管理
    int* raw = p2.release();
    delete raw; // 需手动释放（不推荐，尽量用智能指针全程管理）

    // 6. 重置：reset()释放当前对象，可选新对象
    p2.reset(new int(100)); // 先释放原对象（若有），再管理新对象
    p2.reset(); // 释放对象，变为nullptr

    return 0;
}

#include <cstdio>
#include <memory>

// 自定义删除器：关闭文件
struct FileDeleter {
    void operator()(FILE* fp) const {
        if (fp) std::fclose(fp);
    }
};

int main() {
    // 用自定义删除器创建unique_ptr
    std::unique_ptr<FILE, FileDeleter> fp(std::fopen("test.txt", "w"));
    if (fp) std::fputs("hello", fp.get()); // get()返回裸指针
    // 离开作用域时，自动调用FileDeleter释放文件
    return 0;
}

#include <memory>
#include <iostream>

int main() {
    // 1. 创建：优先用make_shared（更高效）
    auto p1 = std::make_shared<int>(42); 
    std::cout << "use_count: " << p1.use_count() << std::endl; // 输出1

    // 2. 共享所有权：拷贝时计数+1
    auto p2 = p1; 
    std::cout << "use_count: " << p1.use_count() << std::endl; // 输出2

    // 3. 释放所有权：reset()减少计数
    p1.reset(); 
    std::cout << "use_count after p1.reset(): " << p2.use_count() << std::endl; // 输出1

    // 4. 自定义删除器（管理动态数组）
    auto arr = std::shared_ptr<int>(new int[3], [](int* p) { delete[] p; });
    arr.get()[0] = 1; // 访问数组元素

    return 0;
}

#include <memory>

struct A { std::shared_ptr<B> b; };
struct B { std::shared_ptr<A> a; };

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b = b; // A的b指向B，B的计数+1（变为2）
    b->a = a; // B的a指向A，A的计数+1（变为2）
    // 离开作用域时，a和b的计数各减1（变为1），无法释放！
    return 0;
}

struct A { std::weak_ptr<B> b; }; // 弱引用，不增加B的计数
struct B { std::weak_ptr<A> a; }; // 弱引用，不增加A的计数

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b = b; // B的计数仍为1（weak_ptr不增加）
    b->a = a; // A的计数仍为1（weak_ptr不增加）
    // 离开作用域时，a和b的计数各减1（变为0），正常释放！
    return 0;
}

#include <memory>
#include <iostream>

int main() {
    auto sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp; // 弱引用指向sp的对象

    // 1. 检查有效性
    if (!wp.expired()) {
        std::cout << "Object exists" << std::endl;
    }

    // 2. 访问对象：lock()获取shared_ptr
    auto locked_sp = wp.lock();
    if (locked_sp) {
        std::cout << *locked_sp << std::endl; // 输出42
    }

    // 3. 释放原对象
    sp.reset();
    if (wp.expired()) {
        std::cout << "Object has been released" << std::endl;
    }

    return 0;
}