Ahora, mi proyecto tiene dos clases y una de las principales. Desde las dos clases que heredan de uno al otro, ambos son el uso de declaraciones forward. En el primer objeto, justo debajo de la instrucción #include, que me inicializar dos enumeraciones, antes de la definición de la clase. Puedo usar ambas enumeraciones bien dentro de esa clase. Sin embargo, si intento utilizar esas enumeraciones en la otra clase, que hereda de la primera, me sale un error diciendo que la enumeración no ha sido declarada. Si me tratan de redefinir la enumeración en la segunda clase, tengo una redefinición de error.

Incluso he probado a utilizar un truco que acabamos de leer, y poniendo cada uno de enum en su propio espacio de nombres; que no cambió nada.

He aquí un ejemplo:

#ifndef CLASSONE_H
#define CLASSONE_H

namespace Player
{
    enum Enum
    {
        One,
        Two,
    };
}

#endif

A continuación, dentro de la segunda clase, yo intento utilizar la enumeración declarado anteriormente:

void AddPlayer(Player::Enum playerNumber);

y en su lugar sale un error que dice ‘Jugador’ no ha sido declarada.

  • ¿Podría mostrarnos un código simple que demuestra esto?
  • Es la segunda clase #incluyendo «Classone.h»?
  • Sí, y classone es incluyendo classtwo.
  • ¿Por qué es classone incluyendo classtwo? El punto entero de la #ifndef CLASSONE_H es evitar ese tipo de recursivas inclusión. El encabezado de clase base debe ser incluido en la clase derivada de cabecera, desde la clase derivada debe saber lo que se deriva de. La clase base no le importa que se deriva de ella, así que usted no necesita incluir la clase derivada de encabezado en el encabezado de clase base.
  • Classtwo es un administrador de una colección de classones, y classone necesita saber lo que classtwo pertenece a cuando se le preguntó. Se supone que esta es aceptar el uso de declaraciones forward, que me han hecho.
  • Así que no hay base y clases derivadas de participar en todas las? Si usted está adelante declarar las clases, entonces no hay necesidad de incluir las cabeceras en todo.
  • Usted necesita para mostrar a todos sus archivos de encabezado. Esto atrás y hacia delante en el inglés no es útil. Es por eso que tenemos un lenguaje específicamente para ello, que no es ambiguo. Mostrar el código para todos los afectados archivos de encabezado.

InformationsquelleAutor Roderick | 2010-05-22

1 Comentario

  1. 4

    No estoy seguro de lo que el problema que están teniendo sin ver el código, pero esto compila:

    enum OutsideEnum
    {
        OE_1,
        OE_2,
    };
    
    namespace ns
    {
        enum NSEnum
        {
           NE_1,
           NE_2,
        };
    }
    
    class Base
    {
    public:
        enum BaseEnum
        {
            BE_1,
            BE_2,
        };
    
        void BaseFunc();
    };
    
    class Derived
    {
    public:
        enum DerivedEnum
        {
            DE_1,
            DE_2,
        };
    
        void DerivedFunc();
    };
    
    void Base::BaseFunc()
    {
        BaseEnum be = BE_1;
        Derived::DerivedEnum de = Derived::DE_1;
        OutsideEnum oe = OE_1;
        ns::NEEnum ne = ns::NE_1;
    }
    
    void Derived::DerivedFunc()
    {
        Base::BaseEnum be = Base::BE_1;
        DerivedEnum de = DE_1;
        OutsideEnum oe = OE_1;
        ns::NEEnum ne = ns::NE_1;
    }
    
    int main()
    {
        Base::BaseEnum be = Base::BE_1;
        Derived::DerivedEnum de = Derived::DE_1;
        OutsideEnum oe = OE_1;
        ns::NEEnum ne = ns::NE_1;
    }

    Dos cosas que debe observar para con las enumeraciones definido dentro de una definición de clase:

    1. Asegúrese de que sea declarado en público, si usted desea que esté disponible públicamente.
    2. Cuando se hace referencia a él desde cualquier lugar distinto de la clase se define en, utilice el nombre de la clase para calificar el nombre de la enumeración y los valores.

    EDICIÓN:

    Bien, el problema no tiene nada que ver con las enumeraciones, sino más bien el fin de inclusión, cuando usted tiene una clase base y una clase derivada, sólo la clase derivada que necesita saber acerca de la clase base:

    Base de encabezado de la clase:

    #ifndef BASE_H
    #define BASE_H
    
    enum BaseEnum
    {
    };
    
    class Base
    {
    };
    #endif

    Clase derivada de encabezado:

    #ifndef DERIVED_H
    #define DERIVED_H
    
    #include "Base.h"
    
    class Derived
    {
    
       void Func(BaseEnum be);
    };
    #endif
    • Gotcha. El problema fue que escribí la clase derivada antes de que me escribió el administrador, así que me declaró la enumeración en la clase derivada del archivo aunque la clase base necesaria es así. Pensé que una declaración forward sería el fin, pero ese no era el caso. Yo era capaz de obtener el código para compilar mediante la eliminación de los #include «classtwo» y moviendo la enumeración de la clase base (dejando en la declaración a fin de classone podría tener un vector de classtwo).

Dejar respuesta

Please enter your comment!
Please enter your name here