classe qui ne peut être dérivé

Question

J'ai trouvé ce code here

class Usable; 

class Usable_lock { 
    friend class Usable; 
private: 
    Usable_lock() {} 
    Usable_lock(const Usable_lock&) {} 
}; 

class Usable : public virtual Usable_lock { 
    // ... 
public: 
    Usable(); 
    Usable(char*); 
    // ... 
}; 

Usable a; 

class DD : public Usable { }; 

DD dd; // error: DD::DD() cannot access 
     // Usable_lock::Usable_lock(): private member 

Quelqu'un pourrait me expliquer ce code?

EDIT: Une autre question que j'ai est ce qui est une dérivation virtuelle et quand est-il nécessaire?

Answer 1

C'est une propriété de la dérivation virtual.

L'idée de virtual dérivation est de résoudre le "Dreaded motif diamant":

struct Base {}; 

struct D1: Base {}; 
struct D2: Base {}; 

struct TopDiamond: D1, D2 {}; 

Le problème ici est que TopDiamond a 2 instance de Base ici.

Pour résoudre ce problème, "MultiInheritance" très particulier, C++ utilise le mot-clé virtual et ce que l'on appelle ainsi "l'héritage virtuel".

Si nous changeons la façon dont D1 et D2 sont définis tels que:

struct D1: virtual Base {}; 
struct D2: virtual Base {}; 

Ensuite, il n'y aura qu'une seule instance de Base au sein TopDiamond: le travail de l'instanciation en fait il est laissé au sommet constructeur (ici TopDiamond).

Ainsi, le petit truc que vous avez montré simplement expliqué ici:

• parce Usable dérive pratiquement de Usable_lock, il est à sa classe dérivée instancier la Usable_lock partie de l'objet
• parce que Usable_lock constructeur est private, lui-même et ne Usable (ami) peut accéder au constructeur

Il est intelligent, je Je n'y avais jamais pensé. Je me demande quel est le coût de l'héritage virtual ici (surcharge mémoire/vitesse supplémentaire)?

Answer 2

classe Usable_lock « s Constructor est déclarée en privé Il n'est pas accessible à l'extérieur

Usable_lock class 

lorsque vous faites l'objet de

DD dd; 

Il appellera constructeur de Usable et Usable_Lock les deux (parce que DD dérivé de Usable et Usable Dérivé de Usable_lock)

et donc il ne peut pas accéder à Constructor de Usable_Lock .. et il vous donnera erreur

Answer 3

Il y a ici deux points:

1) Pourquoi par exemple utilisable peut être créé, mais il implique constructeur Usable_lock privé ? Parce qu'Usable est ami de Usable_lock.

2) Pourquoi l'instance dérivée de l'utilisable ne peut-elle être créée? Parce qu'il implique un constructeur Usable_lock privé.