C++工程，C++设计模式-原型模式，原型模式和拷贝构造函数的区别

c++常用设计模式
设计模式之原型模式
原型模式和建造者模式、工厂方法模式一样，都属于创建型模式的一种。简单的来说，我们使用原型模式，就是为了创建对象。不过，适合原型模式的最好选择如下：

1.当我们的对象类型不是开始就能确定的，而这个类型是在运行期确定的话，那么我们通过这个类型的对象克隆出一个新的对象比较容易一些；

2.有的时候，我们需要一个对象在某个状态下的副本，此时，我们使用原型模式是最好的选择；例如：一个对象，经过一段处理之后，其内部的状态发生了变化；这个时候，我们需要一个这个状态的副本，如果直接new一个新的对象的话，但是它的状态是不对的，此时，可以使用原型模式，将原来的对象拷贝一个出来，这个对象就和之前的对象是完全一致的了；

3.当我们处理一些比较简单的对象时，并且对象之间的区别很小，可能就几个属性不同而已，那么就可以使用原型模式来完成，省去了创建对象时的麻烦了；

4.有的时候，创建对象时，构造函数的参数很多，而自己又不完全的知道每个参数的意义，就可以使用原型模式来创建一个新的对象，不必去理会创建的过程。

->适当的时候考虑一下原型模式，能减少对应的工作量，减少程序的复杂度，提高效率。

1,运行效果

2,代码示例

#include <iostream>
#include <thread>
#include <mutex>
#include <unistd.h>
#include <list>

enum class ThreadType : int {
    PRODUCTION = 1,
    CONSUMPTION = 2,
};
// the output operator overloading of the enum class ThreadType
std::ostream &operator<<(std::ostream &os, const ThreadType &obj) {
    switch(static_cast<int>(obj)) {
        case static_cast<int>(ThreadType::PRODUCTION) :
            os << "PRODUCTION "; break;
        case static_cast<int>(ThreadType::CONSUMPTION) :
            os << "CONSUMPTION "; break;
    }
    return os;
}
//provides an abstract base class Clone.
class Prototype {
    public:
        virtual Prototype *clone() = 0;
};

class Thread : public Prototype {
    private:
        ThreadType m_type;
        bool m_run_flag = true;
        std::list<int> m_data;
        std::thread m_thread;
    private:
        int produce_data() {
            int count = 0;
            while(m_run_flag) {
                m_data.push_back(count);
                std::cout << "count:" << count << "  list_size:" << m_data.size() <<std::endl;
                count++;
                sleep(1);
            }
        };
        int consume_data() {
            while(m_run_flag) {
                if(!m_data.empty()) {
                    int data = m_data.front();
                    m_data.pop_front();
                    std::cout << "data:" << data << "  list_size:" << m_data.size() <<std::endl;
                    sleep(1);
                }
            }
        };
        int run() {
            std::cout << "thread_type:" << m_type << std::endl;
            switch(static_cast<int>(m_type)) {
                case static_cast<int>(ThreadType::PRODUCTION) :
                    produce_data(); break;
                case static_cast<int>(ThreadType::CONSUMPTION) :
                    consume_data(); break;
                default :
                    std::cerr << "error thread type:" << m_type << std::endl;
            }
        };
    public:
        Thread(ThreadType type):m_type(type) {std::cout << "thread constructor" << std::endl;};
        ~Thread() {m_run_flag = false;};
        //the key code.clone need to call the copy constructor.
        Thread(const Thread& obj) {
            this->m_type = obj.m_type;
            this->m_run_flag = obj.m_run_flag;
            this->m_data = obj.m_data;
            std::cout << "thread copy constructor" << std::endl;
        };
        //the key code. return a copy of the object.
        Prototype* clone() {return new Thread(*this);}
        void setType(ThreadType type) {m_type = type;};
        int startThread() {
            m_run_flag = true;
            m_thread = std::thread(&Thread::run, this);
            m_thread.detach();
            return 0;
        };
};

int main() {
    Thread *thread_1 = new Thread(ThreadType::PRODUCTION);

    thread_1->startThread();
    sleep(5);

    //Prototype mode
    Thread *thread_2 = (Thread *)thread_1->clone();
    thread_2->setType(ThreadType::CONSUMPTION);
    thread_2->startThread();
    sleep(5);

    // copy constructor
    Thread *thread_3 = new Thread(*thread_1);
    thread_3->setType(ThreadType::CONSUMPTION);
    thread_3->startThread();

    int count = 5;
    while(count--){sleep(1);};
    delete thread_1;
    delete thread_2;
    return 0;
}

3,原型模式和拷贝构造函数的区别

相同点：原型模式和拷贝构造函数都是要产生对象的复制品。

不同点：原型模式实现的是一个clone接口，注意是接口，也就是基于多态的clone虚函数。也就是说原型模式能够通过基类指针来复制派生类对象。拷贝构造函数完不成这样的任务。

           原型模式的核心是克隆，构造函数只是克隆的一个办法而已。