C++ Effective Modern Pointer (智能指针模块)

//这些智能指针类型都定义在 <memory> 头文件中，并通过RAII（资源获取即初始化）原则来确保在离开作用域时正确地释放资源。
//使用智能指针可以减少手动管理内存的复杂性和风险，提高代码的安全性和可维护性。
#include<bits/stdc++.h>
using namespace std;
//std::shared_ptr
class MyClass 
{
public:
    MyClass() 
    {
        std::cout << "MyClass constructor" << std::endl;
    }
    ~MyClass() 
    {
        std::cout << "MyClass destructor" << std::endl;
    }
    void sayHello()
    {
        std::cout << "Hello, World!" << std::endl;
    }
};
int main() {
    // 创建第一个shared_ptr对象
    std::shared_ptr<MyClass> ptr1(new MyClass());
    // 使用箭头操作符访问成员函数
    ptr1->sayHello();
    // 创建第二个shared_ptr对象，指向同一个对象
    shared_ptr<MyClass> ptr2 = ptr1;
    
    //在没改变开始进行引用计数 有两个hared_ptr<MyClass>指针指向当前对象
    cout << "Current reference count: " << ptr2.use_count() << std::endl;//2
    // 创建第三个shared_ptr对象，并使用reset方法指向新的对象 可以减少引用
    ptr2.reset(new MyClass());
    // 还可以通过*操作符解引用指针来访问对象的成员函数
    (*ptr2).sayHello();
    // 打印当前引用计数
    cout << "Current reference count: " << ptr2.use_count() << std::endl;//1
    // 最后一个shared_ptr被销毁时自动释放内存资源
    //智能指针被最后释放
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor" << std::endl;
    }
    void sayHello() {
        std::cout << "Hello from MyClass!" << std::endl;
    }
};
int main() {
    // 创建一个管理 MyClass 对象的 unique_ptr
    std::unique_ptr<MyClass> ptr(new MyClass());
    ptr->sayHello();  // 使用箭头运算符访问成员函数
    // 转移所有权给另一个 unique_ptr
    std::unique_ptr<MyClass> otherPtr(std::move(ptr));
    if (ptr == nullptr) {
        std::cout << "ptr is empty!" << std::endl;  // 输出指针为空
    }
    otherPtr->sayHello();  // 在新的 unique_ptr 中访问被管理对象
    return 0;
}

#include <memory>
#include<iostream>
class A;
class B;
class A {
public:
    std::shared_ptr<B> bPtr;
};
class B {
public:
    std::shared_ptr<A> aPtr;
};
int main() {
    std::shared_ptr<A> aPtr = std::make_shared<A>();
    std::shared_ptr<B> bPtr = std::make_shared<B>();
    // 创建循环引用
    aPtr->bPtr = bPtr;
    bPtr->aPtr = aPtr;
    return 0;
}

#include <iostream>
#include <memory>
class MyClass;
// 定义一个使用 weak_ptr 的类
class MyOtherClass {
public:
    std::weak_ptr<MyClass> myPtr;  // 使用 weak_ptr
    void doSomething() {
        if (auto ptr = myPtr.lock()) {  // 使用 lock() 获取 shared_ptr
            std::cout << "Doing something with MyClass object!" << std::endl;
        }
        else {
            std::cout << "MyClass object has been destroyed!" << std::endl;
        }
    }
};
class MyClass {
public:
    std::shared_ptr<MyOtherClass> otherPtr;  // 使用 shared_ptr
    ~MyClass() {
        std::cout << "MyClass destructor" << std::endl;
    }
};
int main() {
    auto obj1 = std::make_shared<MyClass>();
    auto obj2 = std::make_shared<MyOtherClass>();
    obj1->otherPtr = obj2;         // 将 shared_ptr 赋值给成员变量
    obj2->myPtr = obj1;            // 将 weak_ptr 赋值给成员变量
    obj2->doSomething();           // 此时 MyClass 对象还存在
    obj1.reset();                  // 释放对 MyClass 对象的所有权
    obj2->doSomething();           // MyClass 对象已被销毁
    return 0;
}