深入理解 C++11 智能指针：独占、共享与弱引用的完美管理

std::unique_ptr<int> ptr(new int(5));  // 创建unique_ptr并指向动态分配的内存
// 当ptr超出作用域时，内存会被自动释放

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);  // 创建shared_ptr并初始化
std::shared_ptr<int> ptr2 = ptr1;  // 共享资源，引用计数为2

std::weak_ptr<int> weakPtr = ptr1;  // 不增加引用计数
if (auto lockedPtr = weakPtr.lock()) 
{
    // 使用lockedPtr来访问资源
}

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    void greet() { std::cout << "Hello from MyClass!\n"; }
};

int main() 
{
    // 创建 unique_ptr
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    
    // 转移所有权
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    
    if(ptr2) 
    {
        ptr2->greet();  // 正常调用
    }
    
    if(!ptr1) 
    {
        std::cout << "ptr1 is now empty\n";
    }
    
    // 自动释放内存，无需手动delete
    return 0;
}

#include <memory>
#include <iostream>

class Item 
{
public:
    Item() { std::cout << "Item created\n"; }
    ~Item() { std::cout << "Item destroyed\n"; }
};

int main() 
{
    // 创建共享指针
    std::shared_ptr<Item> ptr1 = std::make_shared<Item>();
    
    {
        std::shared_ptr<Item> ptr2 = ptr1;  // 引用计数变为2
        std::cout << "Use count: " << ptr2.use_count() << "\n";  // 输出2
    }  // 引用计数回到1
    
    std::cout << "Use count: " << ptr1.use_count() << "\n";  // 输出1
    
    // 离开作用域时引用计数归零，自动释放内存
    return 0;
}

#include <memory>
#include <iostream>

class Node;

class Parent 
{
public:
    std::shared_ptr<Node> child;
    ~Parent() { std::cout << "Parent destroyed\n"; }
};

class Node 
{
public:
    std::weak_ptr<Parent> parent;  // 使用 weak_ptr 避免循环引用
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() 
{
    auto parent = std::make_shared<Parent>();
    auto node = std::make_shared<Node>();
    
    parent->child = node;
    node->parent = parent;  // 不会增加引用计数
    
    // 离开作用域后对象都能正常销毁
    return 0;
}

int main()
 {
	 // 申请⼀个1G未释放，这个程序多次运⾏也没啥危害 
	 // 因为程序⻢上就结束，进程结束各种资源也就回收了
 
	 char* ptr = new char[1024 * 1024 * 1024];
	 cout << (void*)ptr << endl;
	 return 0;
 }

#include <iostream>

template <typename T>
class MyUniquePtr 
{
private:
    T* ptr;

public:
    // 构造函数
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {}

    // 析构函数，自动释放资源
    ~MyUniquePtr() 
    {
        delete ptr;
    }

    // 移动构造函数
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) 
    {
        other.ptr = nullptr; // 转移所有权
    }

    // 移动赋值运算符
    MyUniquePtr& operator=(MyUniquePtr&& other) noexcept 
    {
        if (this != &other) 
        {
            delete ptr; // 释放当前资源
            ptr = other.ptr;
            other.ptr = nullptr; // 转移所有权
        }
        return *this;
    }

    // 禁用拷贝构造函数和拷贝赋值运算符
    MyUniquePtr(const MyUniquePtr&) = delete;
    MyUniquePtr& operator=(const MyUniquePtr&) = delete;

    // 解引用操作符
    T& operator*() const { return *ptr; }

    // 指针操作符
    T* operator->() const { return ptr; }

    // 获取裸指针
    T* get() const { return ptr; }
};

class MyClass 
{
public:
    void show() 
    {
        std::cout << "MyClass show method\n";
    }
};

int main() 
{
    // 创建 MyUniquePtr，并自动释放资源
    MyUniquePtr<MyClass> ptr1(new MyClass());
    ptr1->show();

    // 使用移动语义
    MyUniquePtr<MyClass> ptr2 = std::move(ptr1);

    // ptr1 现在为空，ptr2 拥有 MyClass 的所有权
    if (!ptr1.get()) 
    {
        std::cout << "ptr1 is null\n";
    }
    ptr2->show();

    return 0;
}

#include <iostream>

template <typename T>
class MySharedPtr 
{
private:
    T* ptr;
    int* ref_count;

public:
    // 构造函数
    explicit MySharedPtr(T* p = nullptr) : ptr(p), ref_count(new int(1)) {}

    // 析构函数
    ~MySharedPtr() 
    {
        --(*ref_count);
        if (*ref_count == 0) 
        {
            delete ptr;
            delete ref_count;
        }
    }

    // 拷贝构造函数
    MySharedPtr(const MySharedPtr& other) : ptr(other.ptr), ref_count(other.ref_count) 
    {
        ++(*ref_count);
    }

    // 拷贝赋值运算符
    MySharedPtr& operator=(const MySharedPtr& other) 
    {
        if (this != &other) 
        {
            // 先减少当前对象的引用计数
            --(*ref_count);
            if (*ref_count == 0) 
            {
                delete ptr;
                delete ref_count;
            }

            // 赋新值
            ptr = other.ptr;
            ref_count = other.ref_count;
            ++(*ref_count);
        }
        return *this;
    }

    // 解引用操作符
    T& operator*() const { return *ptr; }

    // 指针操作符
    T* operator->() const { return ptr; }

    // 获取裸指针
    T* get() const { return ptr; }

    // 获取引用计数
    int use_count() const { return *ref_count; }
};

class MyClass 
{
public:
    void show() 
    {
        std::cout << "MyClass show method\n";
    }
};

int main() 
{
    // 创建 MySharedPtr，并自动管理引用计数
    MySharedPtr<MyClass> ptr1(new MyClass());
    std::cout << "Reference count: " << ptr1.use_count() << std::endl;

    {
        MySharedPtr<MyClass> ptr2 = ptr1;  // ptr2 共享 ptr1 的所有权
        std::cout << "Reference count: " << ptr1.use_count() << std::endl;
        ptr2->show();
    }

    // ptr2 离开作用域后，ptr1 的引用计数减一
    std::cout << "Reference count after ptr2 goes out of scope: " << ptr1.use_count() << std::endl;

    return 0;
}