Herencia privada VS composición: cuándo usar qué?

Question

Herencia privada VS composición.

Estoy teniendo un poco de confusión cuando usar cada uno. Desde sellos herencia privada, en cierto modo, la cadena de herencia, dada:

class A 
{ 
private: 
    int z; 
protected: 
    int y; 
public: 
    int x; 
}; 

class B : private A 
{ 
    /* B's data members and methods */ 
    /* B has access only to A's public and protected */ 
}; 

class C : public B 
{ 
    /* can access no fields of B */ 
}; 

C no será capaz de utilizar cualquiera de los campos B 's. ¿Cuándo usaría la herencia privada y cuándo usaría la composición?

gracias!

Answer 1

This C++ FAQ entry responde a sus preguntas correctamente.

Replicar aquí:

Uso composición cuando se puede, herencia privada cuando tiene que hacerlo.

Normalmente no desea tener acceso a las partes internas de muchas otras clases, y la herencia privada le otorga algo de esta potencia extra (y responsabilidad). Pero la herencia privada no es malvada; es más costoso de mantener, ya que aumenta la probabilidad de que alguien cambie algo que pueda romper tu código.

A, uso legítimo a largo plazo para la herencia privada es cuando se quiere construir una class Fred que utiliza código en un class Wilma, y el código de class Wilma necesita invocar funciones miembro de su nueva clase, Fred. En este caso, Fred llama a los no virtuales en Wilma, y Wilma llamadas (generalmente virtuales puros) en sí mismo, que se reemplazan por Fred. Esto sería mucho más difícil de hacer con la composición.

class Wilma { 
protected: 
    void fredCallsWilma() 
    { 
     std::cout << "Wilma::fredCallsWilma()\n"; 
     wilmaCallsFred(); 
    } 
    virtual void wilmaCallsFred() = 0; // A pure virtual function 
}; 

class Fred : private Wilma { 
public: 
    void barney() 
    { 
     std::cout << "Fred::barney()\n"; 
     Wilma::fredCallsWilma(); 
    } 
protected: 
    virtual void wilmaCallsFred() 
    { 
     std::cout << "Fred::wilmaCallsFred()\n"; 
    } 
};