Question

我在C ++中使用#including文件时遇到问题。当我尝试编译以下代码时

#ifndef TILE_H_INCLUDED
#define TILE_H_INCLUDED
#include "location.h"
#include "Thing.h"
#include "Container.h"
#include <string>
using namespace std;

class Tile              //VIRTUAL CLASS
{
protected:
    Container onTile;   //holds objects that are on the tile
    Location * loc;     //location
    Tile* N;            //links to Tiles of that direction (null if nothing)
    Tile* E;
    Tile* S;
    Tile* W;
public:
//no constructor because superclass?
//loc can't move
//actions
bool placeOnTile(Thing * i){return onTile.addItem(i);}
    //put a thing on the tile (on the floor)
Thing* takeFrmTile(int i){return onTile.movItem(i);}
    //take a thing from the tile (from the floor)
Thing* access(int i) {return onTile.getItem(i);}
    //gets an item, but doesn't move it (for like, flipping switches)

//direction setters/getters
void setLoc(Location* i){loc = i;}
void setN(Tile* i){N = i;}
void setE(Tile* i){E = i;}
void setS(Tile* i){S = i;}
void setW(Tile* i){W = i;}
Location* getLoc(){return loc;}
Tile* getN(){return N;}
Tile* getE(){return E;}
Tile* getS(){return S;}
Tile* getW(){return W;}

//displays
void dispOnTile(){onTile.allDisplay();}
void dispSingle(int i){onTile.singleDisplay(i);}
};

我收到错误消息“Container”和“Thing”未定义。为什么是这样？ #includes看起来像我们编码正确，他们过去一直在工作。我认为这可能是#included文件未正确结束或不使用相同名称空间的问题，但它们正确结束（使用};）并且它们使用标准名称空间。这是怎么回事？我找不到答案，我知道它必须是简单的。为了记录，＃include文件如下：

    #ifndef CONTAINER_H_INCLUDED
#define CONTAINER_H_INCLUDED
#include "Thing.h"
using namespace std;

class Container
{
private:
    Thing ** contents;  //array of pointers to Things
    int numItems;       //count item
    int maxSize;        //maxSize

public:
    //constructor
    Container(int i) {contents = new Thing*[i]; numItems = 0; maxSize=i;}
        //sets num of items (for set-size bags)
    Container() {contents = new Thing*[100]; numItems = 0; maxSize=100;}
        //creates array of things
    ~Container() {delete contents;}  //cleanup

//actions
bool addItem(Thing* th);    //adds item to bag (really just rereferences the pointer)
bool rmvItem(int i);        //removes item in array pos i
Thing* getItem(int i);      //returns a pointer to item at array pos i
Thing* movItem(int i);      //moves an item (deletes it and returns it)

//construction tools
void setMax(int i){delete contents; contents = new Thing*[i];}

//displays
void allDisplay();           //displays entire contents of container, numerated
void singleDisplay(int i);   //displays content item i

};

#endif // CONTAINER_H_INCLUDED

    #ifndef LOCATION_H_INCLUDED
#define LOCATION_H_INCLUDED
#include <string>
#include <sstream>
#include "Tile.h"
using namespace std;

class Location  //stores xy coordinates of something
{
int x;   //0 is NOT on map
int y;
Tile* ti;   //Locations contain pointers to tiles
public:
//constructors (mainly for debug)
Location(){x=y=0;}  //put object OUT OF MAP
Location(int ix, int iy){x=ix;y=iy;} //put object AT loc on map

//setters
void setX(int ix){x=ix;} //sets x
void setY(int iy){y=iy;} //sets y
void setT(Tile*i){ti=i;} //sets Tile

//getters
int getX() {return x;}
int getY() {return y;}
string getloc()     //return location as a string, separated by a comma
{
    ostringstream locxy;    //create stringstream obj to handle input
    locxy << getX() << "," << getY() << ". ";   //put x, space, y into stringstream
    string locret = locxy.str();        //convert stringstream to string
    return locret;                      //return string
    }
};

#endif // LOCATION_H_INCLUDED


    #ifndef THING_H_INCLUDED
#define THING_H_INCLUDED
#include <string>
#include "location.h"
using namespace std;

class Thing             //superclass that will be the base for objects
{
protected:
    Location * loc;     //location (in or out of map)
    string name;        //name
    string desc;        //description
    bool deletable;     //deletable (for undestructible items)
    bool takeable;      //if you can put it in your inv
    bool hasInv;        //returns true if the item has an inventory
public:
//constructor/destructor (debug only)
Thing() //sets initial values
    {loc = new Location(0, 0);
    name = "Uninitialized";
    deletable = takeable = true;
    }
Thing(int ix, int iy)  //sets location
    {loc = new Location(ix, iy);
    name = "Uninitialized";
    deletable = takeable = false;}
~Thing() {delete loc;}              //deletes allocated data

//getters
Location* getLoc() {return loc;}    //returns the location
string getDesc(){return desc;}      //returns the description
bool getDel(){return deletable;}    //returns deletable status
bool getTake(){return takeable;}    //returns takeable status
string getName(){return name;}      //returns name
string dispLoc(){return loc->getloc();} //displays location

//setters
void setName(string s){name = s;}   //sets name
void setDel(bool b){deletable = b;} //sets deletability
void setDesc(string d) {desc = d;}  //sets desc
void setLoc(Location* l) {loc = l;} //sets loc
void setTake(bool b){takeable = b;} //sets takeability

//accessors
};

#endif // THING_H_INCLUDED

Answer 1

我相信这是因为你有递归依赖。也就是说，你的类都依赖于彼此，这意味着在某些时候其中一个类将无法编译，因为为了得到编译它将需要声明一个类，但是，它将无法找到声明，因为它位于“#include”堆栈中已经存在的头文件中，因此防范“#ifdef”变为空。

举个例子。要编译Tile，您需要声明Location，当然，您#include "location.h"。但是，要编译Location的声明，您需要声明Tile，因此，您#include "Tile.h"。但Tile.h 已已#include - 已编辑，因此没有声明！

对抗这种循环依赖的方法是使用不完整的类声明。例如，不要将location.h包含到Tile.h中，而是写

class Location;

class Tile
{
    Location* loc;
}

只要Location仅用于声明指针或引用，并且不会访问Location类的成员，这就可以工作。

然后，在您的“Tile.c”文件中，您可以#include "location.h"并允许Tile方法对Location成员进行访问。

Answer 2

你有一个包含循环

Tile.h包括
1. location.h
2. Thing.h
3. Container.h
Container.h包含Thing.h
Thing.h包含location.h
location.h包含Tile.h

糟糕。

让我们在.cpp中说，首先要包含的是Container.h。然后在声明任何内容之前包括Thing.h。 Thing.h在声明任何内容之前依次包含location.h。然后在声明任何内容之前包括Tile.h。在Tile.h中，所有包含保护使递归包括无操作。

因此Tile.h，Thing和Container未知。

#include文件不包括（c ++）

2 个答案: