Appel explicite destructeur: appeler le bon ? (classes abstraite et dérivée)

Bonjour à tous,

Voici mon problème :

J'ai codé une librairie (calcul scientifique) en C++, et dans une fonction, je dois faire la copie d'un objet alloué dynamiquement (pointé par p2), sur un autre objet déjà alloué dynamiquement (pointé par p1).

Contexte :
- J'ai une classe ABS_BASE qui est abstraite ; p1 et p2 sont des pointeurs de type ABS_BASE*.
- J'ai des classes DERIV1, DERIV2, etc... (dont j'ignore le nombre et les noms a priori) qui dérivent toutes de ABS_BASE
- J'ai dans ABS_BASE une fonction clone() virtuelle pure
- J'ai dans chacune des DERIVn la fonction virtuelle clone() (obligé) qui ne fait que renvoyer un new DERIVn(*this) ---> donc appel du constructeur de recopie + allocation dynamique.

Revenons à ma fonction : elle manipule donc les pointeurs p1 et p2 de type ABS_BASE, mais le type dérivé sous-jacent est évidemment inconnu de ma librairie.

Pour l'instant mon approche (mauvaise en terme de performance mais fonctionnelle) est la suivante :

1. Je delete p1
2. Je fais p1=p2->clone()

Bref, à chaque appel de ma fonction, je fais un delete/new, ce qui est coûteux... sachant que cette fameuse fonction est amenée à être appelée dans des boucles :( .

J'aurais voulu savoir s'il était possible de faire :
1- un appel au BON destructeur via p1 (celui de la classe dérivée sous-jacente en 1er, sachant que je ne connais pas son nom),
2- puis faire un appel au bon constructeur de recopie (là encore, j'ignore son nom) pour que l'emplacement mémoire pointé par p1 soit la copie conforme de l'emplacement mémoire pointé par p2 (+ les allocations dynamiques sous-jacentes)?

Ma première idée était d'ajouter à ABS_BASE une fonction virtual pure "destruct" qui appelle le destructeur, et une fonction virtual pure copy qui appelle le constructeur de copie. L'ennui est qu'il existe déjà des classe DERIV1, DERIV2 etc... sur lesquelles je n'ai pas le contrôle, et où je ne pourrai pas coder ces nouvelles fonctions. En d'autres termes, le mal est fait.

Voilà

Merci à vous !

Sans la certitude totale que les deux objets sont de la même classe, c'est tout simplement impossible, car il n'y a aucune garantie que les deux aient la même taille.
Et si c'est la même classe, implémenter un opérateur = dedans (préférablement par copy-and-swap) suffit.

Bonjour,

J'ai la certitude que les objets sont de même type, mais je ne connais pas leur type dérivé.
C'était à craindre, car il faut que j'aille ajouter du code dans les classes dérivées... Tant pis pour l'erreur de conception.

Merci

Salut,

A vrai dire, la question que je me pose surtout est : pourquoi tiens tu à copier les variables pointées par tes pointeurs :question: et, surtout: pourquoi spécifiquement à cet endroit là :question:

Ne pourrais tu pas envisager -- si la copie des données est réellement indispensable -- de créer une collection de copie, que tu remplirait une bonne fois pour toutes, et que tu utiliserais par la suite :question:

Nota :
1- l'utilisation des pointeurs intelligents (std::unique_ptr en tête) pourrait te faciliter énormément la tache
2- Permettre à une classe ayant sémantique de valeur de se cloner, il faut avoir de très bonne raisons pour le faire, car une classe ayant sémantique d'entité est, classiquement, non copiable ;)