Classes C++ non-copiables et héritage multiple, classes abstraites

Question

Nous pouvons probablement convenir que la construction de copie par défaut est mauvaise la plupart du temps en C++, il est donc préférable de la désactiver explicitement avec C++ 11 =delete ou non-copiable des classes comme boost::noncopyable. La question est: que se passe-t-il dans les scénarios avancés lorsque nous utilisons plusieurs classes d'héritage ou de public abstraite?

//Class uncopyable 
class uncopyable {...}; 

//Interface1 
class IInterface1 : private uncopyable 
{ 
public: 
IInterface1(...) 
virtual ~IInterface1(...) = 0; 
}; 

//Interface2 
class IInterface2 : private uncopyable 
{ 
public: 
IInterface2(...) 
virtual ~IInterface2(...) = 0; 
}; 

//Fancy implementation 
//FImpl 
class FImpl : public IInterface1, public IInterface2, private : uncopyable 
{ 
public: 
FImpl(...) {...} 
~FImpl(...) {...}; 
}; 

• Est-il une bonne pratique de faire toutes les interfaces non copiable (il semble que ce est, pour éviter le découpage)?
• Est-il une bonne pratique d'ajouter incopiable à chaque classe dérivée (de sauvegarde explicite, mais des causes multiples héritage et problèmes diamants?)

Answer 1

Non, ce n'est pas une bonne idée de faire l'interface non copiable. Par exemple, cela empêche le clonage.

Et non, ce n'est pas une bonne idée de dériver de non-copiable dans chaque classe dérivée, parce que c'est juste redondant. Toutefois, afin d'empêcher que Visual C++ produise des avertissements stupides, il peut être judicieux de déclarer un constructeur de copie et un opérateur d'affectation de copie dans chaque classe qui ne peut pas être copiée.

Answer 2

Une classe virtuelle pure (interface) n'a pas besoin d'imposer la gestion de la mémoire pour l'utilisation de l'interface. Les implémentations d'interfaces virtuelles pures devraient déterminer leurs propres exigences de gestion de la mémoire (comme copier et assigner). Cela dit, la sémantique des valeurs permet aux implémentations d'éviter complètement cette situation. Une classe de valeur (copiable, assignable, etc.) est plus facile à raisonner et à utiliser. Toutes les classes de la bibliothèque C++ sont des classes de valeur. Un bon exemple d'une classe de gestion de la mémoire pour elle-même est la classe de chaînes vénérable. Le vecteur est aussi un bon exemple. Ces classes ont des exigences complexes en matière de gestion de la mémoire interne, mais en tant qu'utilisateur de ces classes, je n'ai pas à me préoccuper de cet aspect de la classe. Je peux me concentrer sur la façon d'utiliser la classe.

J'aime ce presentation de C++ Now qui montre comment le polymorphisme est aussi un détail d'implémentation. Cela inclut la possibilité pour un client d'implémenter des classes qui peuvent participer au polymorphisme sans avoir besoin d'une classe d'interface (ou d'une classe de base d'ailleurs).