原型模式，单例模式，工厂模式

原型模式

原型模式就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节（如下面的代码）

• Clone 一定要借助于拷贝构造函数（传入的对象参数必须以引用的方式传入） 才能实现.
• 一般在初始化的信息不发生变化的情况下，克隆是最好的办法，这既隐藏了对象创建的细节，又对性能能是大大的提升。
• 拷贝构造函数和原型模式的区别 ：原型模式实现的是一个Clone 接口，注意是接口，也就是基于多态的 Clone 虚函数。也就是说原型模式能够通过基类指针来复制派生类对象。
• 拷贝构造函数完不成这样的任务。在继承场景下，Clone 函数可以定义为虚函数。

#include <iostream>

class Resume {
private:
    std::string name;
    std::string age;
    std::string education;
public:
    Resume() 
    {
        std::cout << "Construct !" << std::endl;
    };
    Resume(const Resume& resume)
    {
        this->name = resume.name;   
        this->age = resume.age;
        this->education = resume.education;
        std::cout << "Copy Construct !" << std::endl;
    }
    void SetPersonalInfo(const std::string& name, const std::string& age)
    {
        this->name = name;
        this->age = age;
    }
    void SetEducation(const std::string& educatoin)
    {
        this->education = educatoin;
    }
    void PrintResume()
    {
        std::cout << name << ", " << age  << ", " << education << std::endl;
    }
    Resume* Clone()
    {
        return new Resume(*this);
    }
};
int main()
{
    Resume* p1 = new Resume();
    p1->SetPersonalInfo("Tom", "25");
    p1->SetEducation("master");
    p1->PrintResume();

    Resume* p2 = p1->Clone();
    p2->SetPersonalInfo("Jack", "28");
    p2->PrintResume();
}

单例模式

• 就是说一个类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
• 其优点是可以避免一个全局使用的类频繁创建与销毁，节省系统资源。
• 构造函数是私有的，防止外界再创建单例类对象
• 使用类的 静态 私有 指针 指向类的唯一实例
• 使用共有的静态方法获取该实例
• 总结为一点就是：隐藏类的构造函数，实现一个getinstance方法来让外界或者这个实例。
• 在初始化这个类的时候要注意，访问静态成员变量的时候 可以直接是用 类名::静态方法或静态属性 来访问

class Car
{
private:
    std::string name;
    std::string id;
    int *p = new int[10];
    //构造函数也应该是私有的
    Car(std::string x, std::string y):name(x),id(y){
        for(auto i = 0; i < 10; i++){
            p[i] = i;
        }
        std::cout << "structure" << std::endl;
    };
    ~Car(){
        if(p != nullptr){
            delete[] p;
        }
        std::cout<< "destory!" <<std::endl;
    }
    //使用一个静态 私有 指针指向唯一的实例；
private:
    static Car* instance;
    
public:
    static Car* getinstance(){
        if(instance == nullptr){
            instance = new Car("audi","鄂000329");
        }
        return instance;
    }
    std::string getname();
};

std::string Car::getname(){
    return this->name;
}

//初始化Car
Car* Car::instance = Car::getinstance();

int main(){
    std::cout<< Car::getinstance()->getname()<< std::endl;
    std::cin.get();
}

工厂模式

• 专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。
• 工厂父类负责定义创建产品对象的公告接口，而工厂子类负责生成具体的产品对象。
• 目的是将产品的实例化操作延迟到工厂子类中完成，通过工厂子类来确定究竟应该实例化哪一个具体产品类。

参考连接：三种工厂模式