#include <iostream>
using namespace std;
class Person {
public:
    string name = "小舞";
};
int main() {
    const Person * p1 = new Person();
    // p1->name = "Derry"; // 報(bào)錯(cuò)：常量指針，不寫(xiě)修改值
    Person * p2 = const_cast<Person *>(p1); // 轉(zhuǎn)成 非常量指針
    p2->name = "唐三";
    cout << p1->name.c_str() << endl;
    return 0;
}

class FuClass {
public:
    void show() {
        cout << "fu show" << endl;
    }
};
class ZiClass  : public FuClass {
public:
    void show() {
        cout << "zi show" << endl;
    }
};
int main() {
    FuClass * fuClass = new FuClass;
    // fuClass->show();
    ZiClass * ziClass = static_cast<ZiClass *>(fuClass);
    ziClass->show();
    delete fuClass; 
    return 0;
}

#include <iostream>
using namespace std;
class FuClass {
public:
    // 動(dòng)態(tài)轉(zhuǎn)換必須讓父類(lèi)成為虛函數(shù)
    virtual void show() {
        cout << "fu show" << endl;
    }
};
class ZiClass  : public FuClass {
public:
    void show() {
        cout << "zi show" << endl;
    }
};
int main() {
    // FuClass * fuClass = new FuClass(); // 失敗
    FuClass * fuClass = new ZiClass; //子類(lèi) 成功
    ZiClass * ziClass = dynamic_cast<ZiClass *>(fuClass);
    if (ziClass) { // ziClass != null
        cout << "轉(zhuǎn)換成功 " ;
        ziClass->show();
    } else {
        cout << "轉(zhuǎn)換失敗" << endl ;
    }
    return 0;
}

#include <iostream>
using namespace std;
class Handler {
public:
    void show() {
        cout << "handler" << endl;
    }
};
int main() {
    Handler * handler = new Handler();
    long handlerValue = reinterpret_cast<long>(handler); // 把對(duì)象變成數(shù)值
    // 通過(guò)數(shù)值 變成對(duì)象
    Handler * handler2 = reinterpret_cast<Handler *>(handlerValue);
    handler2->show();
    printf("handler:%p\n", handler);
    printf("handler2:%p\n", handler2);
}

#include <iostream>
#include <memory>
using namespace std;
class Person2; // 先聲明 Person2 讓我們的Person1 直接找到
class Person1 {
public:
    shared_ptr<Person2> person2; // Person2智能指針  shared_ptr 引用計(jì)數(shù)+1
    ~Person1() {
        cout << "Person1 析構(gòu)函數(shù)" << endl;
    }
};
class Person2 {
public:
    shared_ptr<Person1> person1;  // Person1智能指針  shared_ptr 引用計(jì)數(shù)+1
    ~Person2() {
        cout << "Person2 析構(gòu)函數(shù)" << endl;
    }
};
int main(){
    Person1 * person1 = new Person1(); // 堆區(qū)開(kāi)辟
    Person2 * person2 = new Person2(); // 堆區(qū)開(kāi)辟
    shared_ptr<Person1> sharedPtr1(person1); // +1 = 1
    shared_ptr<Person2> sharedPtr2(person2); // +1 = 1
    cout << "前 sharedPtr1的引用計(jì)數(shù)是:" << sharedPtr1.use_count() << endl;
    cout << "前 sharedPtr2的引用計(jì)數(shù)是:" << sharedPtr2.use_count() << endl;
//    // 給Person2智能指針賦值   循環(huán)依賴(lài) 智能指針就失去了自動(dòng)釋放內(nèi)存的功能了
//    person1->person2 = sharedPtr2;
//    // 給Person1智能指針賦值
//    person2->person1 = sharedPtr1;
//
//
//    cout << "后 sharedPtr1的引用計(jì)數(shù)是:" << sharedPtr1.use_count() << endl;
//    cout << "后 sharedPtr2的引用計(jì)數(shù)是:" << sharedPtr2.use_count() << endl;
    return 0;
}

#include <iostream>
#include <memory> // 智能指針的頭文件引入
using namespace std;
class Person2; // 先聲明 Person2 讓我們的Person1 直接找到
class Person1 {
public:
    weak_ptr<Person2> person2; // Person2智能指針  沒(méi)有引用計(jì)數(shù) 無(wú)法+1
    ~Person1() {
        cout << "Person1 析構(gòu)函數(shù)" << endl;
    }
};
class Person2 {
public:
    weak_ptr<Person1> person1;  // Person1智能指針  沒(méi)有引用計(jì)數(shù) 無(wú)法+1
    ~Person2() {
        cout << "Person2 析構(gòu)函數(shù)" << endl;
    }
};
int main() {
    Person1 * person1 = new Person1(); // 堆區(qū)開(kāi)辟
    Person2 * person2 = new Person2(); // 堆區(qū)開(kāi)辟
    shared_ptr<Person1> sharedPtr1(person1); // +1 = 1
    shared_ptr<Person2> sharedPtr2(person2); // +1 = 1
    cout << "前 sharedPtr1的引用計(jì)數(shù)是:" << sharedPtr1.use_count() << endl;
    cout << "前 sharedPtr2的引用計(jì)數(shù)是:" << sharedPtr2.use_count() << endl;
    // 給Person2智能指針賦值
    person1->person2 = sharedPtr2;
    // 給Person1智能指針賦值
    person2->person1 = sharedPtr1;
    cout << "后 sharedPtr1的引用計(jì)數(shù)是:" << sharedPtr1.use_count() << endl;
    cout << "后 sharedPtr2的引用計(jì)數(shù)是:" << sharedPtr2.use_count() << endl;
    return 0;
} // 減1 = 0 釋放對(duì)象

#include <iostream>
#include <memory> // 智能指針的頭文件引入
using namespace std;
class Person {
public:
    ~Person(){
        cout<<"析構(gòu)函數(shù)"<<endl;
    }
};
int main() {
    Person * person1 = new Person();
    Person * person2 = new Person();
    unique_ptr<Person> uniquePtr1(person1);
    // 嚴(yán)格禁止
//     std::unique_ptr<Person> uniquePtr2 = uniquePtr1;  unique不允許，因?yàn)槭仟?dú)占的
    // shared_ptr 是可以的，會(huì)造成隱患問(wèn)題
    return 0;
}

#include <iostream>
using namespace std;
template<typename T>
class Ptr{
private:
    T * object;         // 用于智能指針指向管理的對(duì)象  Person Student
    int * count;        //引用計(jì)數(shù)
public:
    Ptr(){
        count=new int(1);  // new 的對(duì)象 必須 *指針  
        object=0;  // 因?yàn)槟銢](méi)有給他對(duì)象 智能賦值為0
    }
    Ptr(T *t):object(t){
//        只有你存入對(duì)象，那么引用計(jì)數(shù)為1，這個(gè)是很合理的
        count=new int(1);
    }
    ~Ptr(){
        if (--(*count)==0){
            if (object){
                delete object;
            }
            delete count;
            object=0;
            count=0;
        }
    }
    //拷貝構(gòu)造函數(shù)
    Ptr(const Ptr<T> & p){
        cout << "拷貝構(gòu)造函數(shù)" << endl;
        ++(*p.count);
        object = p.object;
        count = p.count; // 最終是不是 p.count==2 給 count==2
    }
    // 自定義 =號(hào)運(yùn)算符重載
    Ptr<T> & operator = (const Ptr<T> & p){
        cout << "=號(hào)運(yùn)算符重載" << endl;
        ++(*p.count);

        if (--(*count) == 0) {
            if (object) {
                delete object;
            }
            delete count;
        }
        object = p.object;
        count = p.count;
        return *this; // 運(yùn)算符重載的返回
    }
    // 返回引用計(jì)數(shù)的數(shù)值
    int use_count() {
        return *this->count;
    }
};
int main(){
    //自定義智能指針的應(yīng)用
    Student *student1 = new Student();
    Student *student2 = new Student();
    Ptr<Student> sharedPtr1(student1);
    Ptr<Student> sharedPtr2(student2);
    return 0;
}