c++ - una - Herencia privada VS composición: ¿cuándo usar cuál?

que es una clase en c++

Question

Herencia privada VS composición.

Estoy teniendo un poco de confusión cuando usar cada uno. Dado que la herencia privada sella, en cierto modo, la cadena de la herencia, dado:

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 podrá usar ninguno de los campos de B ¿Cuándo usaría la herencia privada, y cuándo usaría la composición?

¡Gracias!

Answer 1

Esta entrada de Preguntas frecuentes de C ++ responde a tus preguntas de manera adecuada.

Replicándolo aquí:

Use la composición cuando pueda, herencia privada cuando tenga que hacerlo.

Normalmente, no desea tener acceso a las partes internas de demasiadas otras clases, y la herencia privada le brinda parte de este poder adicional (y responsabilidad). Pero la herencia privada no es mala; el mantenimiento es simplemente más caro, ya que aumenta la probabilidad de que alguien cambie algo que rompa su código.

Un uso legítimo a largo plazo para la herencia privada es cuando desea crear una class Fred que usa código en una class Wilma , y el código de la class Wilma necesita invocar funciones de miembro de su nueva clase, Fred . En este caso, Fred llama no virtuales en Wilma , y Wilma llama (generalmente virtuales puros) en sí mismo, que son reemplazadas 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";
     }
 };