Ereditare da classi protette in C ++

Question

Supponiamo che io abbia la seguente dichiarazione:

class Over1
{
   protected:
      class Under1
      {
      };
};

So che potrei fare quanto segue:

class Over2 : public Over1
{
   protected:
        class Under2 : public Under1
        {
        };
};

Ma c'è un modo per dichiarare Under2 senza Over2?

Dato che dovresti estendere Over1 per usare qualsiasi derivato di Under1 questo può sembrare sciocco, ma in questa situazione potrebbero esserci 30 diversi gusti di Under. Posso:

• Inseriscili tutti in Over1: No attraente poiché Over2 può usare solo 1 o 2 di essi
• Inseriscili ciascuno la propria versione di Over: Not attraente da allora avrai moltiplicare ereditare da quasi il stessa classe.
• Trova un modo per creare figli di Under1 senza creare figli di Over1

Quindi è possibile?

Grazie.

Answer 1

Utilizzando modelli e specializzazioni esplicite puoi farlo con una sola dichiarazione di classe aggiuntiva in Over1.

class Over1
{
protected:
  class Under1
  {
  };

  template <typename T>
  class UnderImplementor;
};

struct Under2Tag;
struct Under3Tag;
struct Under4Tag;

template <>
class Over1::UnderImplementor<Under2Tag> : public Over1::Under1
{
};

template <>
class Over1::UnderImplementor<Under3Tag> : public Over1::Under1
{
};

template <>
class Over1::UnderImplementor<Under4Tag> : public Over1::Under1
{
};

Spero che questo aiuti.

Answer 2

Meglio della creazione di classi nidificate, potresti voler considerare l'incorporamento di quei closs in uno spazio dei nomi. In questo modo, non è necessaria la classe esterna per ottenere la classe interna. Ci sono alcuni grandi argomenti a favore e contro nella Guida allo stile di Google C ++ .

Answer 3

Se vuoi mantenere Under1 protetto, per definizione devi ereditare da Over1 per accedervi. Suggerirei di rendere Under1 pubblico o di usare gli spazi dei nomi come suggerito da Douglas.

Non ho il compilatore per testarli adesso, quindi non sono affatto sicuro che funzionino, ma puoi provare questo:

class Over1
{
   protected:
      class Under1
      {
      };

   public:
      class Under1Interface : public Under1 
      {
      };
};

class Under2 : public Over1::Under1Interface
{
};

O forse qualcosa del genere:

class Over1
{
   protected:
      class Under1
      {
      };
};

class Under2 : private Over1, public Over1::Under1
{
};

O anche:

class Under2;

class Over1
{
   friend class Under2;

   protected:
      class Under1
      {
      };
};

class Under2 : public Over1::Under1
{
};

Anche se questo esporrebbe tutti gli Over1 privati ??a Under2 - probabilmente non qualcosa che vorresti.

Answer 4

Mi sembra un po 'un design originale. Perché non provare a strutturare il codice in modo diverso. Penso che questo potrebbe essere un buon candidato per il modello di decoratore, in cui potresti avvolgere la tua classe di base in vari decoratori per ottenere la funzionalità desiderata, i vari sapori di 'under' potrebbero essere decoratori. Solo un pensiero, difficile da dire senza sapere di più sulle intenzioni del tuo codice.