int* pi = new int(10); //利用傳統(tǒng)指針在堆區(qū)開辟一個(gè)存放整數(shù)的區(qū)域
std::unique_ptr<int> u_pi_01{pi};//通過傳統(tǒng)指針創(chuàng)建智能指針
std::unique_ptr<int> u_pi_02{pi};//有意讓兩個(gè)獨(dú)占指針同時(shí)指向同一個(gè)內(nèi)存區(qū)域

//由于指針的本質(zhì)也是變量，離開作用范圍就會(huì)自動(dòng)釋放
//因此我們需要通過在外部創(chuàng)建變量來保存指針?biāo)４娴牡刂?
int* external_pi_1;//用于存儲(chǔ)傳統(tǒng)指針的地址
int* external_pi_2;//用于存儲(chǔ)智能指針的地址
 {
    int *pi = new int(10);//使用傳統(tǒng)指針在堆區(qū)開辟內(nèi)存存儲(chǔ)整形
    external_pi_1 = pi;   
    std::unique_ptr<int> u_pi{new int(10)};//使用智能指針在堆區(qū)開辟內(nèi)存存儲(chǔ)
    external_pi_2 = u_pi.get();
    std::cout << *external_pi_1 << std::endl;//輸出10
    std::cout << *external_pi_2 << std::endl;//輸出10
 }
std::cout << *external_pi_1 << std::endl;//輸出10
std::cout << *external_pi_2 << std::endl;//輸出0

std::unique_ptr<int> u_pi1 = std::make_unique<int>(10);
//std::unique_ptr<int> u_pi2 = u_pi1;//嘗試用拷貝的方式共享內(nèi)存，error:可別忘了這是獨(dú)占指針
std::unique_ptr<int> u_pi2 = move(u_pi1);使用move方法轉(zhuǎn)移內(nèi)存擁有權(quán)。

int* pi = new int(10); //使用傳統(tǒng)指針在堆區(qū)開辟一個(gè)空間
std::unique_ptr<int> u_pi{pi};//利用創(chuàng)通指針創(chuàng)建智能指針

std::unique_ptr<int> u_pi{new int(10)};

std::unipue_ptr<int> u_pi = std::make_unique<int>(10);

void show(std::unique_ptr<int> u_pi)
{
    std::cout<<*u_pi<<std::endl;
}
void test()
{
    std::unique_ptr<int> u_pi{new int(10)};
    show(move(u_pi)); //通過move轉(zhuǎn)移擁有權(quán)
}

void show(const std::unique_ptr<int> &u_pi)//加cosnt 不是不能改變指向的值，不能改變指針的指向
{
    std::cout << *u_pi << std::endl;
    //u_pi.reset();加了const所以不能清空
}
void test()
{
    std::unique_ptr<int> u_pi{new int(10)};
    show(u_pi);
}

std::unique_ptr<Person> get_unique(std::string str)
{
    std::unique_ptr<Person> u_pi{new Person(str)};
    return u_pi;
}
void test()
{
    get_unique("hua")->show();//鏈?zhǔn)?
}

class Person
{
public:
    Perosn(std::string name):m_name(name){};
    void show()
    {
        std::cout<<"name is "<<m_name<<std::endl;
    }
private:
    std::string m_name;   
};
int main()
{
std::unique_ptr<Person> u_p{new Person("kimi")}; //用自定義類型創(chuàng)建
u_p->show();//可以通過->調(diào)用函數(shù)
(*u_p).show();//通過*解引用
std::cout<<u_p.get()<<std::endl;//通過get()獲取地址
u_p.reset();//清空指針
return 0;
}

int* pi = new int(10);
std::unique_ptr<int> u_pi{pi};//使用傳統(tǒng)指針創(chuàng)建，上式開辟的區(qū)域被獨(dú)占
*pi = 20; //沒有及時(shí)清空，依然可以通過獨(dú)占指針以外的方式修改內(nèi)存

std::shared_ptr<int> u_pi_1{new int(10)};
std::shared_ptr<int> u_pi_2 = u_pi_1;//通過復(fù)制拷貝

std::shanred_ptr<int> s_pi{new int(10)}; //s_pi.use_count() == 1
std::shanred_ptr<int> s_pi_copy = s_pi;  //s_pi.use_count() == 2
s_pi = nullptr;//清空指針                 //s_pi_copy.use_count() == 1

std::shared_ptr<int> s_pi{new int(10)}; //s_pi.use_count() == 1
std::shared_ptr<int> s_pi_2 = s_pi;     //s_pi.use_count() == 2
std::shared_ptr<int> s_pi_3 = s_pi_2;   //s_pi.use_count() == 3
s_pi_2 = bullptr; //清空2指針            //s_pi.use_count() == 2

void get_use_1(std::shared_ptr<int> s_pi)
{
    std::cout << s_pi.use_count() << std::endl;
}
void get_use_2(std::shared_ptr<int>& s_pi)
{
    std::cout << s_pi.use_count() << std::endl;
}
void test()
{
    std::shared_ptr<int> s_pi{new int(10)};
    std::cout << s_pi.use_count() << std::endl;
    get_use_1(s_pi);//在函數(shù)中計(jì)數(shù)會(huì)增加，但隨著函數(shù)銷毀，計(jì)數(shù)復(fù)原
    get_use_2(s_pi);//以引用方式傳入，指針還是那個(gè)指針，計(jì)數(shù)不會(huì)增加
}

class Person
{
public:
    void set_friend(share_ptr<Person> p)
 
    _friend = p;
private:
    share_ptr<Person> _frient;
};
int main()
{
   share_ptr<Person> p1 = make_shared("P1");
   share_ptr<Person> p2 = make_shared("P2");
    p1->set_friend(P2);
    p2->set_friend(P1);//造成循環(huán)依賴，在main中的話，不會(huì)執(zhí)行析構(gòu)
}

class Person
{
public:
    void set_friend(share_ptr<Person> p)
    _friend = p;
private:
    weak_ptr<Person> _frient;//使用weak_ptr解決循環(huán)依賴
};
int main()
{
    share_ptr<Person> p1 = make_shared("P1");
    share_ptr<Person> p2 = make_shared("P2");
    p1->set_friend(P2);
    p2->set_friend(P1);
}

std::weak_ptr<Person> w_pi{new Person("hua")};
std::shared_ptr <Person> s_pi2 = w_pi.lock();