C++ 智能指针

template<typename T, typename Deleter = std::default_delete<T>>
class unique_ptr {
private:
    T* ptr;
    Deleter del;
    
    // 禁用复制构造
    unique_ptr(const unique_ptr&) = delete;
    // 禁用复制赋值
    unique_ptr& operator=(const unique_ptr&) = delete;
    
public:
    // 构造函数
    explicit unique_ptr(T* p = nullptr) : ptr(p) {}
    
    // 移动构造函数
    unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    // 移动赋值运算符
    unique_ptr& operator=(unique_ptr&& other) noexcept {
        if (this != &other) {
            del(ptr);  // 释放当前资源
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
    
    // 析构函数
    ~unique_ptr() {
        del(ptr);
    }
    
    // 其他成员函数...
};

#include <memory>
#include <iostream>

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

int main() {
    // 创建unique_ptr
    std::unique_ptr<MyClass> up1(new MyClass());
    
    // 使用箭头运算符访问成员
    up1->doSomething();
    
    // 使用解引用运算符
    (*up1).doSomething();
    
    // 所有权转移（移动语义）
    std::unique_ptr<MyClass> up2 = std::move(up1);
    
    // up1现在为空
    if (!up1) {
        std::cout << "up1 is null\n";
    }
    
    // 自定义删除器示例
    auto deleter = [](MyClass* p) {
        std::cout << "Custom deleter called\n";
        delete p;
    };
    
    std::unique_ptr<MyClass, decltype(deleter)> up3(new MyClass(), deleter);
    
    // 数组版本
    std::unique_ptr<MyClass[]> up4(new MyClass[3]);
    
    return 0;
}

template<typename T>
class shared_ptr {
private:
    T* ptr;                  // 指向对象的指针
    control_block* control;  // 指向控制块的指针
    
    struct control_block {
        std::size_t ref_count;    // 引用计数
        std::size_t weak_count;   // 弱引用计数
        // 其他信息：删除器、分配器等
    };
    
public:
    // 构造函数
    explicit shared_ptr(T* p = nullptr) : ptr(p) {
        if (p) {
            control = new control_block{1, 0};
        } else {
            control = nullptr;
        }
    }
    
    // 复制构造函数
    shared_ptr(const shared_ptr& other) : ptr(other.ptr), control(other.control) {
        if (control) {
            ++control->ref_count;
        }
    }
    
    // 析构函数
    ~shared_ptr() {
        if (control) {
            --control->ref_count;
            if (control->ref_count == 0) {
                delete ptr;          // 释放对象
                if (control->weak_count == 0) {
                    delete control;  // 当没有弱引用时，释放控制块
                }
            }
        }
    }
    
    // 其他成员函数...
};

#include <memory>
#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass(int id) : id_(id) { 
        std::cout << "MyClass " << id_ << " constructed\n"; 
    }
    ~MyClass() { 
        std::cout << "MyClass " << id_ << " destructed\n"; 
    }
    void doSomething() { 
        std::cout << "MyClass " << id_ << " doing something\n"; 
    }
private:
    int id_;
};

int main() {
    // 创建shared_ptr
    std::shared_ptr<MyClass> sp1(new MyClass(1));
    std::cout << "Reference count: " << sp1.use_count() << "\n";
    
    // 复制shared_ptr，引用计数增加
    std::shared_ptr<MyClass> sp2 = sp1;
    std::cout << "Reference count after copy: " << sp1.use_count() << "\n";
    
    // 通过make_shared创建（更高效）
    auto sp3 = std::make_shared<MyClass>(2);
    
    // 存储在容器中
    std::vector<std::shared_ptr<MyClass>> vec;
    vec.push_back(sp1);
    vec.push_back(sp2);
    vec.push_back(sp3);
    std::cout << "sp1 reference count: " << sp1.use_count() << "\n";
    
    // 函数参数传递
    auto func = [](std::shared_ptr<MyClass> sp) {
        std::cout << "In function, ref count: " << sp.use_count() << "\n";
    };
    func(sp1);
    
    // 自定义删除器
    auto deleter = [](MyClass* p) {
        std::cout << "Custom deleter for MyClass " << p->id_ << "\n";
        delete p;
    };
    std::shared_ptr<MyClass> sp4(new MyClass(3), deleter);
    
    return 0;
}

#include <memory>
#include <iostream>

class B; // 前向声明

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

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

int main() {
    // 创建循环引用场景
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    
    a->b_ptr = b;
    b->a_ptr = a;
    
    // 此时a和b的引用计数都是1
    std::cout << "a use count: " << a.use_count() << "\n";
    std::cout << "b use count: " << b.use_count() << "\n";
    
    // 通过weak_ptr访问对象
    if (auto locked = b->a_ptr.lock()) {
        std::cout << "Successfully locked a from b\n";
        std::cout << "Locked a use count: " << locked.use_count() << "\n";
    } else {
        std::cout << "a has been destroyed\n";
    }
    
    // weak_ptr的过期检查
    std::weak_ptr<A> weak_a = a;
    a.reset(); // 重置a，引用计数减为0
    
    if (weak_a.expired()) {
        std::cout << "weak_a has expired\n";
    } else {
        std::cout << "weak_a is still valid\n";
    }
    
    return 0;
}

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass(int id) : id_(id) { 
        std::cout << "MyClass " << id_ << " constructed\n"; 
    }
    ~MyClass() { 
        std::cout << "MyClass " << id_ << " destructed\n"; 
    }
private:
    int id_;
};

int main() {
    std::auto_ptr<MyClass> ap1(new MyClass(1));
    
    // 复制auto_ptr会转移所有权
    std::auto_ptr<MyClass> ap2 = ap1;
    
    // ap1现在变为空，访问会导致未定义行为
    // ap1->someMethod(); // 危险！
    
    return 0;
}