Design patterns
Motif Prototype
Recherche…
Introduction
Le modèle Prototype est un modèle de création qui crée de nouveaux objets en clonant un objet prototype existant. Le modèle prototype accélère l'instanciation des classes lorsque la copie d'objets est plus rapide.
Remarques
Le motif prototype est un motif de conception créative. Il est utilisé lorsque le type d'objets à créer est déterminé par une instance de prototype, qui est "clonée" pour produire de nouveaux objets.
Ce modèle est utilisé lorsqu'une classe a besoin d'un constructeur "polymorphe (copie)" .
Motif Prototype (C ++)
class IPrototype {
public:
virtual ~IPrototype() = default;
auto Clone() const { return std::unique_ptr<IPrototype>{DoClone()}; }
auto Create() const { return std::unique_ptr<IPrototype>{DoCreate()}; }
private:
virtual IPrototype* DoClone() const = 0;
virtual IPrototype* DoCreate() const = 0;
};
class A : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<A>{DoClone()}; }
auto Create() const { return std::unique_ptr<A>{DoCreate()}; }
private:
// Use covariant return type :)
A* DoClone() const override { return new A(*this); }
A* DoCreate() const override { return new A; }
};
class B : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<B>{DoClone()}; }
auto Create() const { return std::unique_ptr<B>{DoCreate()}; }
private:
// Use covariant return type :)
B* DoClone() const override { return new B(*this); }
B* DoCreate() const override { return new B; }
};
class ChildA : public A {
public:
auto Clone() const { return std::unique_ptr<ChildA>{DoClone()}; }
auto Create() const { return std::unique_ptr<ChildA>{DoCreate()}; }
private:
// Use covariant return type :)
ChildA* DoClone() const override { return new ChildA(*this); }
ChildA* DoCreate() const override { return new ChildA; }
};
Cela permet de construire la classe dérivée à partir d'un pointeur de classe de base:
ChildA childA;
A& a = childA;
IPrototype& prototype = a;
// Each of the following will create a copy of `ChildA`:
std::unique_ptr<ChildA> clone1 = childA.Clone();
std::unique_ptr<A> clone2 = a.Clone();
std::unique_ptr<IPrototype> clone3 = prototype.Clone();
// Each of the following will create a new default instance `ChildA`:
std::unique_ptr<ChildA> instance1 = childA.Create();
std::unique_ptr<A> instance2 = a.Create();
std::unique_ptr<IPrototype> instance3 = prototype.Create();
Motif Prototype (C #)
Le modèle prototype peut être implémenté à l'aide de l'interface ICloneable dans .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Motif Prototype (JavaScript)
Dans les langages classiques comme Java, C # ou C ++, nous commençons par créer une classe, puis nous pouvons créer de nouveaux objets à partir de la classe ou nous pouvons étendre la classe.
En JavaScript, nous créons d'abord un objet, puis nous pouvons augmenter l'objet ou en créer de nouveaux. Donc, je pense, JavaScript montre un prototype réel que le langage classique.
Exemple :
var myApp = myApp || {};
myApp.Customer = function (){
this.create = function () {
return "customer added";
}
};
myApp.Customer.prototype = {
read: function (id) {
return "this is the customer with id = " + id;
},
update: function () {
return "customer updated";
},
remove: function () {
return "customer removed";
}
};
Ici, nous créons un objet nommé Customer , puis sans créer de nouvel objet, nous avons étendu l' Customer object existant à l'aide d' un mot-clé prototype . Cette technique est appelée modèle de prototype .
