Herdar a partir de classes protegidos em C ++

Question

Suponha que eu tenho a seguinte declaração:

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

Eu sei que eu poderia fazer o seguinte:

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

Mas há uma maneira de declarar under2 sem Over2?

Uma vez que você teria que estender Over1 usar qualquer derivado de under1 isso pode parecer bobagem, mas nesta situação não pode ser de 30 sabores diferentes de Under. I pode:

• Colocá-los todos dentro Over1: Não atraente desde Over2 pode usar apenas 1 ou 2 deles
• Coloque-os cada um em sua própria versão de Over: Não atraente, desde então, você terá Para herdar multiplicam a partir de praticamente o mesma classe.
• Encontre uma maneira de criar filhos de under1 sem criar filhos de Over1

Então, isso é possível?

Graças.

Answer 1

Usando modelos e especializações explícitas você pode fazer isso com apenas uma declaração de classe adicional no 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
{
};

Espero que isso ajude.

Answer 2

Melhor do que a criação de classes aninhadas, você pode querer olhar para incorporar esses closses em um namespace. Dessa forma, você não precisa da classe externa a fim de obter a classe interna. Existem alguns grandes argumentos a favor e contra no Google C ++ .

Answer 3

Se você quiser manter under1 protegido, então, por definição, você precisa para herdar de Over1 para acessá-lo. Eu sugeriria fazer pública under1, ou usando namespaces como Douglas sugeriu.

Eu não tenho o compilador para testar estes para fora agora, então eu não tenho certeza de que estes iria funcionar, mas você pode tentar o seguinte:

class Over1
{
   protected:
      class Under1
      {
      };

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

class Under2 : public Over1::Under1Interface
{
};

Ou talvez algo como isto:

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

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

Ou mesmo:

class Under2;

class Over1
{
   friend class Under2;

   protected:
      class Under1
      {
      };
};

class Under2 : public Over1::Under1
{
};

Apesar de que iria expor todos os privates Over1s para under2 -. Provavelmente não algo que você gostaria

Answer 4

soa como um pouco de um projeto funky para mim. Por que não tentar estruturar o código de forma diferente. Eu acho que isso poderia ser um bom candidato para o padrão de decorador, onde você poderia envolver sua classe base em vários decoradores para alcançar a funcionalidade desejada, as várias versões de 'sob' poderia ser decoradores. Apenas um pensamento, difícil dizer sem saber mais sobre as intenções de seu código.