unique_ptr<Data> p6(new Data());
//不可復制構造和賦值復制
//unique_ptr<Data>p7 = p6; 錯誤

//p6釋放所有權 轉移到p7
unique_ptr<Data>p7 = move(p6);

unique_ptr<Data>p8(new Data());
p7 = move(p8);//重新移動賦值，原有的p6會被釋放掉
//重置空間，原空間清理
p7.reset(new Data());

//釋放所有權
unique_ptr<Data>p9(new Data());
auto ptr9 = p9.release();//注意，release釋放所有權以后要自己清理空間
delete ptr9;//?。。。。。?

void process_data(
    std::unique_ptr<Data> p1, 
    std::unique_ptr<Data> p2
);

process_data(
    std::unique_ptr<Data>(new Data("A")),  // 分配資源 A
    std::unique_ptr<Data>(new Data("B"))   // 分配資源 B
);

process_data(
    std::make_unique<Data>("A"),  // 直接構造并接管資源 A
    std::make_unique<Data>("B")   // 直接構造并接管資源 B
);

std::unique_ptr<MyClass, Deleter> p(new MyClass, custom_deleter);

class Data
{
public:
	Data() {

		cout<< "Begin Data" << endl;
	}
	~Data() { cout<< "End Data" << endl; }
	int index1 = 0;
	int index2 = 0;
};

{
	shared_ptr<Data>sc1(new Data);
	//打印引用計數 = 1
	cout << "sc1.use_count() = " << sc1.use_count() << endl;

	shared_ptr<int>sc2(sc1,&sc1->index1);//引用計數+1
	shared_ptr<int>sc3(sc1, &sc1->index2);//引用計數+1
	//打印引用計數 = 3
	cout << "sc1.use_count() = " << sc1.use_count() << endl;
}

	class A
	{
	public:
		A() { cout << "Create A" << endl; }
		~A() { cout << " Drop A " << endl; }

		void Do()
		{
			cout << "Do b2.use_count() = " << b2.use_count() << endl;
			auto b = b2.lock(); //復制一個shared_ptr 引用計數加一
			cout << "Do b2.use_count() = " << b2.use_count() << endl;

		}

		shared_ptr<B> b1;//強智能指針
		weak_ptr<B> b2;  //弱智能指針
	};
	class B
	{
	public:
		B() { cout << "Create B" << endl; }
		~B(){ cout << " Drop B " << endl; }
		shared_ptr<A> a1;//強智能指針
		weak_ptr<A> a2;  //弱智能指針

	};

	{
		auto a = make_shared<A>();//a引用計數+1
		auto b = make_shared<B>();//b引用計數+1

		a->b1 = b;//b引用計數+1
		//出作用域前，引用計數為2
		cout << "a->b1 = b;b.use_count()=" << b.use_count() << endl;

		b->a1 = a;//a引用計數+1
		//出作用域前，引用計數為2
		cout << "b->a1 = a;a.use_count()=" << a.use_count() << endl;

	}

	{
		auto a = make_shared<A>();
		auto b = make_shared<B>();

		a->b2 = b;//weak_ptr 引用計數不加一
		a->Do();//Do函數里引用計數加一,出Do函數作用域減一
		cout << "a->b2 = b;b.use_count()=" << b.use_count() << endl;

		b->a2 = a;//引用計數不加一
		cout << "b->a2 = a;a.use_count()=" << a.use_count() << endl;

	}//不會產生循環(huán)引用問題

void Do()
{
	cout << "Do b2.use_count() = " << b2.use_count() << endl;
	auto b = b2.lock(); //返回一個shared_ptr 引用計數加一
	
	//這里還可以做其他的訪問shared_ptr資源的操作

	cout << "Do b2.use_count() = " << b2.use_count() << endl;

}//出作用域加上的那個引用計數自動-1

    if (auto a_shared = b->a_weak.lock()) {
        // 返回nullptr 說明shared_ptr被釋放
        //不會執(zhí)行此處
    } else {
 		//引用計數+1
        std::cout << "A is already destroyed!" << std::endl;  // 輸出此句
    }//引用計數-1

std::shared_ptr<MyClass> p(new MyClass);

class BackgroundWorker {
public:
    void startWork() {
        // 錯誤：裸指針 this 跨線程傳遞，主線程可能提前釋放對象
        std::thread([this]() {
            doWork(); // 可能訪問已銷毀對象！
        }).detach();
    }

    void doWork() { /* 自己實現(xiàn)的操作 */ }
};

int main() {
    auto worker = std::make_shared<BackgroundWorker>();
    worker->startWork();
    worker.reset(); // 主線程釋放對象
    // 子線程仍在執(zhí)行 doWork()，this 已失效！
}

class BackgroundWorker : 
public std::enable_shared_from_this<BackgroundWorker> {
public:
    void startWork() {
        // 正確：通過 shared_from_this() 傳遞所有權
        std::thread([self = shared_from_this()]() {
            self->doWork(); // 安全：self 確保對象存活
        }).detach();
    }
    // ...
};

class TreeNode {
public:
    void addChild() {
        // 創(chuàng)建一個子節(jié)點 child，用 shared_ptr 管理
        auto child = std::make_shared<TreeNode>();
        
        // 錯誤：直接用 this 創(chuàng)建新的 shared_ptr，賦值給 child->parent
        //child->parent引用計數也是 1
        child->parent = std::shared_ptr<TreeNode>(this); // 危險！
        
        // 將 child 添加到當前節(jié)點的 children 列表中
        children.push_back(child);
    }

    std::shared_ptr<TreeNode> parent;  // 父節(jié)點用 shared_ptr 管理
    std::vector<std::shared_ptr<TreeNode>> children; // 子節(jié)點列表
};

int main() {
    // 創(chuàng)建一個根節(jié)點 root，用 shared_ptr 管理
    auto root = std::make_shared<TreeNode>();//root引用計數是 1
    root->addChild(); // 調用 addChild，導致雙重釋放！
}

class TreeNode : public std::enable_shared_from_this<TreeNode> {
public:
    void addChild() {
        auto child = std::make_shared<TreeNode>();
        
        // 通過 shared_from_this() 獲取與 root 共享所有權的 shared_ptr
        child->parent = shared_from_this(); // 引用計數 +1
        
        children.push_back(child);
    }

    std::shared_ptr<TreeNode> parent;
    std::vector<std::shared_ptr<TreeNode>> children;
};

int main() {
    auto root = std::make_shared<TreeNode>();
    root->addChild(); // 安全：root 的引用計數變?yōu)?2
}