Cita:
Iniciado por vangodp *_*
Voy a probar esto
Tiene sus limitaciones, solo te sirve para hacer declaraciones o usos "abstractos". No puedes ni hacer malloc, ni adceder a sus atributos internos... Lo unico que puedes hacer es definir y copiar el puntero de un lado a otro. La única utilidad que le veo es para resolver conflictos.
Voy a sacar un proyecto donde uso está tecnica para resolver un conflicto:
Figura.hpp
Código C++:
Ver original#include "Tablero.hpp"
class Figura
{
public:
Figura(Tablero &m,bool color) : mat(m),Color(color){}
bool getColor() const {return Color;}
virtual int mover(Cord,Cord) = 0;
virtual int tipo() const = 0;
/*...*/
protected:
Tablero &mat;
bool Color;
};
Tablero.hpp
Código C++:
Ver original#include "Cord.hpp"
class Figura;
class Tablero
{
public:
static const bool BLANCO = 0;
static const bool NEGRO = 1;
Tablero();
Figura* getPosition(Cord posicion) const;
bool jaque(bool color);
/* ... */
private:
Figura* Matriz[8][8];
/*...*/
};
Fijate bien, Figura tiene una referencia al tablero actual. Y tablero contiene una matriz de figuras, ambos se referencian mutuamente.
Es absurdo hacer:
Tablero.hpp
Figura.hpp
Tablero incluye a figura, y luego desde ahí vuelvo a incluir a figura... Si no le pongo protección contra la inclusión multiple fallará, y si se la pongo, una no encontrará a la otra.
Asi que opté una táctica distinta, figura.hpp incluye a tablero.hpp. Pero tablero.hpp no la incluye, sino que usa el prototipo. Luego en la implementación (.cpp) si incluyo a figura completamente:
Tablero.cpp
Código C++:
Ver original#include "Tablero.hpp"
#include "Figura.hpp"
//...