Modo de prototipo
La idea del modo prototipo es obtener uno o más objetos idénticos o similares copiando un objeto existente.
El principio de funcionamiento del modo prototipo es pasar un objeto prototipo al objeto a crear, el cliente, y el cliente realiza el proceso de creación solicitando al objeto prototipo que se copie a sí mismo. Para entender de acuerdo con el método de fábrica, el nuevo objeto de fábrica creado es la clase prototipo en sí.
El proceso de creación de algunos objetos en el sistema de software es más complicado y, a veces, debe crearse con frecuencia. El modo de prototipo especifica el tipo de objeto que se va a crear dando un objeto prototipo, y luego crea más objetos del mismo tipo copiando el objeto prototipo., Esta es la intención del patrón prototipo.
Estructura de prototipo
La estructura del prototipo incluye los siguientes roles:
- Prototipo abstracto: declara la interfaz del propio clon
- Clase de prototipo concreto (ConcretePrototype): implementar la interfaz de clonación
- Cliente: se declara una clase de prototipo abstracto en el cliente y las instancias de objeto de clase de prototipo concretas se clonan de acuerdo con las necesidades del cliente.
Copia superficial, copia profunda
Se puede decir que el patrón prototipo es una copia de la propia clase, pero esta copia no es una copia del código, sino una copia de todos los atributos contenidos en el objeto. Sin embargo, diferentes operaciones de copia pueden producir dos copias diferentes, divididas en copia superficial y copia profunda.
Copia superficial
En una copia superficial, si la variable miembro del objeto prototipo es un tipo de valor (como int, double, char y otros tipos de datos básicos), se copiará una copia en el objeto de copia; si la variable miembro del objeto prototipo es una referencia / puntero, será referenciado / La dirección apuntada por el puntero se copia en el objeto de copia, es decir, las variables miembro en el objeto prototipo y el objeto de copia apuntan a la misma dirección.
Copia profunda
En una copia en profundidad, no importa si la variable miembro en el objeto prototipo es un tipo de valor o un tipo de puntero / referencia, se copiará una copia en el objeto de copia.
Tenga en cuenta que en la copia profunda, el puntero / objeto de referencia también se copiará al objeto de copia.
Ejemplo de patrón de prototipo
prototype_pattern.h
#include <iostream>
#include <string.h>
using namespace std;
//work model类
class WorkModel
{
public:
string modelName;
void setWorkModelName(string iName){
this->modelName = iName;
}
};
//抽象原型类PrototypeWork
class PrototypeWork
{
public:
PrototypeWork(){
}
virtual PrototypeWork *clone() = 0;
private:
};
//具体原型类ConcreteWork
class ConcreteWork :public PrototypeWork
{
public:
ConcreteWork(){
}
ConcreteWork(string iName, int iIdNum, string modelName){
this->name = iName;
this->idNum = iIdNum;
this->workModel = new WorkModel();
this->workModel->setWorkModelName(modelName);
}
ConcreteWork *clone(){
ConcreteWork *work = new ConcreteWork();
work->setName(this->name);
work->setIdNum(this->idNum);
work->workModel = this->workModel;
return work;
}
void setName(string iName){
this->name = iName;
}
void setIdNum(int iIdNum){
this->idNum = iIdNum;
}
void setModel(WorkModel *iWorkModel){
this->workModel = iWorkModel;
}
//打印work信息
void printWorkInfo(){
cout << "name:\t" << this->name << endl;
cout << "idNum:\t" << this->idNum << endl;
cout << "modelName:\t" << this->workModel->modelName << endl;
}
// private:
string name;
int idNum;
WorkModel *workModel;
};
prototype_pattern.cpp
#include "prototype_pattern.h"
int main()
{
// 赋值
#if 0
ConcreteWork *BasicWork = new ConcreteWork("basic", 1001, "basic_Model");
cout << "\nBasic Work：\n";
BasicWork->printWorkInfo();
ConcreteWork *CopyWork = BasicWork;
cout << "\nCopy Work：\n";
CopyWork->printWorkInfo();
cout << "\nCopy 完成后，记得跟新WorkName，Num以及ModelName！\n";
CopyWork->setName("CopyWork");
CopyWork->setIdNum(1002);
WorkModel *CopyModel = new WorkModel();
CopyModel->setWorkModelName("Copy_Model");
CopyWork->setModel(CopyModel);
cout << "\nBasic Work \n";
BasicWork->printWorkInfo();
cout << "\nCopy Work \n";
CopyWork->printWorkInfo();
delete CopyModel;
delete CopyWork;
#else
// 克隆
ConcreteWork *BasicWork = new ConcreteWork("basic", 1001, "Basic_Model");
cout << "\nBasic Work：\n";
BasicWork->printWorkInfo();
ConcreteWork *CopyWork = BasicWork->clone();
cout << "\nCopy Work：\n";
CopyWork->printWorkInfo();
cout << "\nCopy 完成后，记得跟新WorkName，Num以及ModelName ！\n";
CopyWork->setName("CopyWork");
CopyWork->setIdNum(1002);
WorkModel *CopyModel = new WorkModel();
CopyModel->setWorkModelName("Copy_Model");
CopyWork->setModel(CopyModel);
//检查下是否改对了
cout << "\nBasic Work \n";
BasicWork->printWorkInfo();
cout << "\nCopy Work \n";
CopyWork->printWorkInfo();
delete BasicWork;
delete CopyModel;
delete CopyWork;
#endif
return 0;
}
Tenga en cuenta la diferencia entre asignación de comparación y copia
Resumen del modo prototipo
ventaja:
- Cuando la creación de una nueva instancia de objeto es más complicada, el modo de prototipo puede simplificar el proceso de creación y mejorar la eficiencia de la creación de objetos;
- Extensible: las clases de prototipos abstractos se proporcionan en el patrón y las clases de prototipos concretos se pueden extender de manera apropiada;
- La estructura de creación es simple: la creación de la fábrica es el objeto prototipo en sí
Desventajas:
- El código de clonación profunda es más complicado;
- Cada clase debe estar equipada con un método de clonación, y el método está ubicado dentro de la clase, lo que viola el principio de apertura y cierre cuando se modifica;
Entorno aplicable:
- Cuando la creación de una nueva instancia de objeto es más complicada, el modo de prototipo puede simplificar el proceso de creación;
- Combinando las ventajas del artículo 3, es necesario evitar el uso de clases de fábrica jerárquicas para crear objetos jerárquicos, y el objeto de instancia de la clase tiene solo uno o unos pocos estados combinados. Al copiar el objeto prototipo para obtener una nueva instancia, es mejor que usar un constructor, es más conveniente crear una nueva instancia.