#include <iostream>
#include <string>
#include <memory>

using std::cout;
using std::endl;
using std::string;
using std::shared_ptr;
using std::make_shared;

template <typename T> class Singleton;

class Point
{
    //由于構(gòu)造和析構(gòu)被設(shè)為私有，想使用單例模板創(chuàng)造對(duì)象，就應(yīng)該把其設(shè)為友元
    template <typename T> friend class Singleton;
    
public:
    //把析構(gòu)函數(shù)設(shè)為private之后，智能指針銷毀時(shí)無(wú)法調(diào)用
    //所以析構(gòu)應(yīng)該設(shè)置為public，但是就算是共有的析構(gòu)，由于是把單例對(duì)象的內(nèi)容托管給了智能指針
    //通過(guò)智能指針顯式的調(diào)用析構(gòu)函數(shù)，也是無(wú)法回收單例對(duì)象的，所以，不影響單例模式的實(shí)現(xiàn)
    ~Point(){
        cout << "~Point()" << endl;
    }

    void show(){
        cout << "(" << _ix << ", " << _iy << ")" << endl;
    }

private:
    //單例模式，要把構(gòu)造函數(shù)和析構(gòu)函數(shù)設(shè)為私有
    Point(int x, int y) : _ix(x), _iy(y)
    {
        cout << "Point(int, int)" << endl;
    }
    /* ~Point(){ */
    /*     cout << "~Point()" << endl; */
    /* } */

private:
    int _ix;
    int _iy;
};

class Computer
{
    //由于構(gòu)造和析構(gòu)被設(shè)為私有，想使用單例模板創(chuàng)造對(duì)象，就應(yīng)該把其設(shè)為友元
    template <typename T> friend class Singleton;

public:
    void show(){
        cout << "name: " << _name << "  price: " << _price << endl;
    }
    void reset(const string &newname, const int &newprice){
        _name = newname;
        _price = newprice;
    }
    
    //使用public的析構(gòu)函數(shù)，不影響單例模式的實(shí)現(xiàn)
    ~Computer(){
        cout << "~Computer()" << endl;
    }

private:
    //單例模式，要把構(gòu)造函數(shù)設(shè)為私有
    //使用模板生成單例對(duì)象的時(shí)候調(diào)用了make_shared函數(shù)，如果傳入的是棧上的內(nèi)容
    //make_shared函數(shù)會(huì)調(diào)用拷貝構(gòu)造函數(shù)在堆上重新生成一個(gè)托管給智能指針的對(duì)象，
    //并把原先的對(duì)象銷毀，所以會(huì)在make_shared里面執(zhí)行一次析構(gòu)函數(shù)
    /* Computer(const Computer &rhs){ */
    /*     cout << "拷貝構(gòu)造函數(shù)" << endl; */
    /* } */
    Computer(const string &name, const int price)
        :_name(name), _price(price) 
    {
        cout << "Computer(const string &, const int &)" << endl;
    }
    /* ~Computer(){ */
    /*     cout << "~Computer()" << endl; */
    /* } */

private:
    string _name;
    int _price;
};

//模板形式的單例類(使用了智能指針)，應(yīng)該使用飽漢模式
template <typename T>
class Singleton
{
public:
    template <typename ...Args> 
        static shared_ptr<T> getInstance(Args... args){
            if(_pInstance == nullptr){
                //這里會(huì)直接調(diào)用相應(yīng)的類型的構(gòu)造函數(shù)，托管給智能指針，類型在實(shí)例化后確定
                /* //使用臨時(shí)對(duì)象托管給智能指針的時(shí)候，由于臨時(shí)對(duì)象分配在棧上， */
                /* //所以在make_shared內(nèi)部會(huì)重新分配堆上的空間來(lái)保存其內(nèi)容， */
                /* //會(huì)調(diào)用拷貝構(gòu)造函數(shù)，并把臨時(shí)對(duì)象銷毀 */
                /* _pInstance = make_shared<T>(T(args...)); */

                //如果把一個(gè)分配在堆上的指針托管給智能指針，傳入的指針就不會(huì)被銷毀
                T *tmp = new T(args...);
                _pInstance = make_shared<T>(*tmp);
            }
            return _pInstance;
        }

private:
    //由于使用了模板，所以_pInstance實(shí)際上指向的是 T ，而非本類型，
    //所以并不會(huì)生成Singleton對(duì)象，而是直接生成相應(yīng)的T對(duì)象
    //T在實(shí)例化之后才會(huì)確定，究竟是哪種類型，
    //所以Singleton的構(gòu)造函數(shù)和析構(gòu)函數(shù)并不會(huì)執(zhí)行
    Singleton(){
        cout << "Singleton()" << endl;
    }

    ~Singleton(){
        cout << "~Singleton()" << endl;
    }

    static shared_ptr<T> _pInstance;  //單例模式的指針，指向唯一的實(shí)體
};

//由于類型在實(shí)例化是才會(huì)確定，所以使用飽漢模式
template <typename T>
shared_ptr<T> Singleton<T>::_pInstance = nullptr;

#include "template_singleton.hpp"
#include <stdio.h>

using std::cout;
using std::endl;
using std::cin;

void test(){
    shared_ptr<Computer> pc1 = Singleton<Computer>::getInstance("Xiaomi", 6666);
    cout << "pc1: ";
    pc1->show();

    shared_ptr<Computer> pc2 = Singleton<Computer>::getInstance("Xiaomi", 6666);
    cout << "pc1: ";
    pc1->show();
    cout << "pc2: ";
    pc2->show();

    pc2->reset("Huawei", 8888);
    cout << endl << "after pc2->reset()" << endl;
    cout << "pc1: ";
    pc1->show();
    cout << "pc2: ";
    pc2->show();
    cout << endl;

    shared_ptr<Point> pt3 = Singleton<Point>::getInstance(1, 2);
    shared_ptr<Point> pt4 = Singleton<Point>::getInstance(1, 2);

    cout << endl << "通過(guò)模板，可以生成不同類型的單例對(duì)象:" << endl;
    cout << "pt3: ";
    pt3->show();
    cout << "pt4: ";
    pt4->show();

    cout << endl << "使用了智能指針，不同對(duì)象指向的地址也一樣：" << endl;
    printf("&pc1 = %p\n", &pc1);
    printf("&pc2 = %p\n", &pc2);
    printf("&pt3 = %p\n", &pt3);
    printf("&pt4 = %p\n\n", &pt4);
    printf("&(*pc1) = %p\n", &(*pc1));
    printf("&(*pc2) = %p\n", &(*pc2));
    printf("&(*pt3) = %p\n", &(*pt3));
    printf("&(*pt4) = %p\n\n", &(*pt4));

}

int main()
{
    test();
    return 0;
}

Computer(const string &, const int &)
pc1: name: Xiaomi  price: 6666
pc1: name: Xiaomi  price: 6666
pc2: name: Xiaomi  price: 6666

after pc2->reset()
pc1: name: Huawei  price: 8888
pc2: name: Huawei  price: 8888

Point(int, int)

# 通過(guò)模板，可以生成不同類型的單例對(duì)象:
pt3: (1, 2)
pt4: (1, 2)

# 使用了智能指針，不同對(duì)象指向的地址也一樣：
&pc1 = 0x7ffe83bbd390
&pc2 = 0x7ffe83bbd3a0
&pt3 = 0x7ffe83bbd3b0
&pt4 = 0x7ffe83bbd3c0

&(*pc1) = 0x55b750c7e300
&(*pc2) = 0x55b750c7e300
&(*pt3) = 0x55b750c7e360
&(*pt4) = 0x55b750c7e360

~Point()
~Computer()