Je veux effectuer des "copies profondes" d'un conteneur stl de Je sais sur le modèle em> prototype em> modèle de conception, mis en œuvre au moyen de L'idiome cors virtuel em>, comme expliqué dans le C ++ FAQ Lite, point 20.8 . une copie profonde est alors le suivant: p> Comme Andrei Alexandrescu State It : P> Le clone En outre, les clients de Ma question est la suivante: y a-t-il un autre façon de faire une classe de base abstraite clonable sans nécessiter de classes dérivées pour écrire le code associé à clone? (Classe d'assistance? Modèles?) P> Suivant est mon contexte. Espérons que cela aidera à comprendre ma question. P> Je concevra une hiérarchie de classe pour effectuer des opérations sur une classe plusieurs opérations multiples peuvent être effectuées. Séquentiellement sur une image: p> S'il y a plusieurs images, l'ensemble peut être divisé et partagé sur plusieurs threads. Pour assurer la "sécurité de thread-sécurité", chaque thread doit avoir sa copie édité: strong> La version thread-coffre-fort utilise le modèle de conception prototype pour appliquer la copie de pointe-des-objets em> - - NON PTRS: P>
C'est simple et simple: p> inconvénients h1>
() code> La mise en œuvre doit suivre le même motif dans toutes les classes dérivées; Malgré sa structure répétitive, il n'y a pas de moyen raisonnable d'automatiser la définition de la fonction de clone code> (au-delà des macros, c'est-à-dire). P>
BlockQuote> ABC code> peuvent éventuellement faire quelque chose de mauvais. (Je veux dire, rien n'empêche les clients à faire quelque chose de mal, alors, il sera em> arriver.) P> Meilleur design? H1>
image code>: p> imgop code>: p> v code> - v code> devient un prototype à être copié en profondeur dans chaque fil. P> struct ImgOp
{
virtual ~ImgOp() {}
bool run( Image & ) = 0;
virtual ImgOp * clone() = 0; // virtual ctor
};
struct CheckImageSize : public ImgOp { /* no clone code */ };
struct CheckImageResolution : public ImgOp { /* no clone code */ };
struct RotateImage : public ImgOp { /* no clone code */ };
bool do_operations( vector< ImgOp* > v, Image &i )
{
// In another thread
vector< ImgOp* > v2;
transform( v.begin(), v.end(), // Copy pointed-to-
back_inserter( v2 ), mem_fun( &ImgOp::clone ) ); // objects
for_each( v.begin(), v.end(),
/* bind2nd( mem_fun( &ImgOp::run ), i ... ) don't remember syntax */ );
}
3 Réponses :
Vous pouvez utiliser le motif curieusement récursif mais cela pourrait rendre votre code moins lisible.
Vous aurez toujours besoin de constructeurs de copies. Cela fonctionne comme suit.
+1 bonne approche. Comme indiqué dans l'article Tyler mentionné dans un commentaire, vous n'avez plus de type de retour covariant. Je n'ai jamais compris pourquoi c'était si gros problème. Les endroits où j'appellerais une méthode de clone, je ne connais pas de toute façon le type dérivé.
Si je comprends bien, cela ne fonctionnera pas si j'ai besoin de sous-classement SOMABCIMPL , non?
J'ai pensé à cette solution mais le rejeté car le client doit toujours écrire un code associé à clone: le paramètre de modèle de clonableabc . Du point de vue du client, l'intention de ce paramètre de modèle n'est pas claire et pourrait sembler inutile.
doublep> en effet. Pas avec ce morceau de code. Julien L.> Je comprends votre choix. Cela pourrait être un peu trompeur pour le client.
Je dirais qu'il est en fait possible d'automatiser
clone () (si un peu inélégant): nerdland.net/2009/06/...@Tyler Mchenry: Mais la fabrication automatique encouragerait la mauvaise utilisation, puis C ++ commencerait à ressembler à Java. Je dirais que presque tous les usages de clone () ont tort (dans les quelques cas où il est nécessaire, laissez les gens faire le travail de la mettre en œuvre) comme malheureusement, c'est un moyen simple à utiliser de manière incorrecte, ce qui entraîne une mauvaise conception et une mauvaise mise en œuvre.
Quel est le problème avec simplement définir et utiliser le constructeur de copie comme il était censé? Comme @Martin dit, vous ne voulez absolument pas que des objets soient traitablement claquables.