c++ - Declaración directa y dependencia circular

dependencies declaration

Question

Tengo dos clases, Entidad y Nivel. Ambos necesitan acceder a métodos el uno del otro. Por lo tanto, al usar #include, surge la cuestión de las dependencias circulares. Por lo tanto para evitar esto, intenté declarar Nivel en Entidad.h:

class Level { };

Sin embargo, como la Entidad necesita acceso a los métodos en Level, no puede acceder a dichos métodos, ya que no sabe que existen. ¿Hay alguna manera de resolver esto sin volver a declarar la mayoría del Nivel en la Entidad?

Answer 1

Una declaración adelantada correcta es simplemente:

class Level;

Tenga en cuenta la falta de llaves. Esto le dice al compilador que hay una clase llamada Level , pero nada sobre el contenido de la misma. A continuación, puede utilizar punteros ( Level * ) y referencias ( Level & ) a esta clase indefinida libremente.

Tenga en cuenta que no puede instanciar directamente Level porque el compilador necesita saber el tamaño de la clase para crear variables.

class Level;
class Entity
{
Level &level; // legal
Level level; // illegal
};

Para poder utilizar Level en los métodos de Entity , lo ideal es definir los métodos de Level en un archivo .cpp separado y solo declararlos en el encabezado. Separar declaraciones de definiciones es una mejor práctica de C ++.

// entity.h
class Level;
class Entity
{
void changeLevel(Level &);
};
// entity.cpp
#include "level.h"
#include "entity.h"
void Entity::changeLevel(Level &level)
{
level.loadEntity(*this);
}

Answer 2

usted dos opciones:

1. use punteros en cuyo caso su forward declara que debería estar bien.
2. alinee los métodos de una clase, en cuyo caso si incluye el archivo .h puede usar los métodos de la otra.

Personalmente, iría por la ruta número 1, es más limpia y permite un mejor acceso. Uso mucho shared_ptr así que no tengo que preocuparme por las eliminaciones ...

Entity.h:
class Level;
class Entity {
private:
Level* m_pLevel;
public:
bool CheckLevel ();
bool WasItThere();
Level.h
class Entity;
class Level {
private:
Entity* m_pEntity;
public:
public bool CheckMyStuff();
public bool CheckItOut() { return m_pEntity->WasItThere();}
}
Entity.cpp
#include "Level.h"
bool Entity::CheckLevel () {
return true;
}
bool Entity::CheckLevel() {
return m_pLevel->CheckMyStuff();
}
bool Entity::WasItThere() {
return true;
}
Level.cpp
bool Level::CheckMyStuff() {
return true;
}
bool Level::CheckItOut() {
return m_pEntity->WasItThere();
}