Prototipo (modo de diseño c ++)

Modelo de prototipo El ejemplo de prototipo especifica el tipo de objeto que se creará y para crear nuevos objetos copiando este prototipo

Ventajas del modelo

• Simplifica la creación de objetos
• Buena escalabilidad
• Proporciona una estructura de creación simple
• El estado del objeto se puede guardar en un clon profundo

Desventajas del modelo

• Cada clase debe estar equipada con un método de clonación, y el método se encuentra dentro de una clase. Cuando se modifica la clase existente, el código fuente debe modificarse, lo que viola el principio de apertura y cierre.
• Necesita escribir código más complejo al implementar la clonación profunda

Entorno aplicable

• Crear un objeto nuevo es caro
• El sistema necesita guardar el estado del objeto, y el estado del objeto cambia muy poco
• Necesidad de evitar el uso de clases de fábrica jerárquicas para crear objetos.
• Ctrl + C 、 Ctrl + V

Código de prototipo

/*
 * @ Description: C++ Design Patterns___Prototype
 * @ version: v1.0
 * @ Author: WeissxJ
 */
#include<iostream>
#include<string>

class Prototype
{
    
    
    public:
        virtual ~Prototype() {
    
    }

        virtual Prototype* clone()=0;
        virtual std::string type()=0;
        // ...
};

class ConcretePrototypeA : public Prototype
{
    
    
    public:
        ~ConcretePrototypeA() {
    
    }
        
        Prototype* clone(){
    
    
            return new ConcretePrototypeA();
        }
        std::string type(){
    
    
            return "type A";
        }
        // ...
};

class ConcretePrototypeB : public Prototype
{
    
    
    public:
        ~ConcretePrototypeB() {
    
    }
        
        Prototype* clone(){
    
    
            return new ConcretePrototypeB();
        }
        std::string type(){
    
    
            return "type B";
        }
        // ...
};

class Client
{
    
    
    private:
        static Prototype* types[2];
        static int n_types;
    public:
        static void init(){
    
    
            types[0]=new ConcretePrototypeA();
            types[1]=new ConcretePrototypeB();
        }

        static void remove(){
    
    
            delete types[0];
            delete types[1];
        }

        static Prototype* make(const int index){
    
    
            if(index>=n_types){
    
    
                return nullptr;
            }
            return types[index]->clone();
        }
        // ...
}; 

Prototype* Client::types[2];
int Client::n_types=2;

int main(){
    
    
    Client::init();

    Prototype* prototype1=Client::make(0);
    std::cout<<"Prototype: "<<prototype1->type()<<std::endl;
    delete prototype1;

    Prototype* prototype2=Client::make(1);
    std::cout<<"Prototype: "<<prototype2->type()<<std::endl;
    delete prototype2;

    Client::remove();

    return 0;
}