3

我在一个头文件中定义了一个名称空间并在另一个头文件中使用，但找不到它。具体来说，在“players/Players.hpp”中定义并在名为“players/Ownable.hpp”的文件中使用的名为“players”的命名空间在名为“combat/Targetable.hpp”的文件中找不到

错误是

...\source\combat\Targetable.hpp(7): 'players' : is not a class or namespace name
...\source\combat\Targetable.hpp(7): 'Ownable' : base class undefined

显然这是我不明白的一些语法。我花了一些时间简化代码，所以它看起来很傻，但请耐心等待。

// source/players/Players.hpp:
#ifndef PLAYERS_HPP
#define PLAYERS_HPP

#include "../Headers.hpp"

namespace players {
  class Player{

// this class compiles fine.
// There used to be a "Players.cpp" but it's been simplified away

    public:
      int getID(){ return 0; }
      int getTeam(){ return 0; }
      string getName(){ return ""; }
      Vec3 getColor(){ return Vec3(0.0,0.0,0.0); }
  };
}
#endif

还有 player/Ownable.hpp，它与 Player.hpp 位于同一文件夹中，并且编译良好：

// source/players/Ownable.hpp:
#ifndef OWNABLE_HPP
#define OWNABLE_HPP

#include "Players.hpp"

namespace players {
  class Ownable;
  typedef boost::shared_ptr<Ownable> OwnablePTR;
  typedef boost::weak_ptr<Ownable> OwnableWPTR;

  class Ownable {
    public:
      Ownable(){}
      Ownable(int playerID) : playerID(playerID){}
      bool isAlliedWith(OwnablePTR other){ return false; }

    private:
      int playerID;
  };
}

#endif

这就是乐趣的开始。我在“source/combat/Targetable.hpp”中有一个文件，该文件与其他两个文件位于不同的目录中。但是，文件本身似乎包含罚款：

// source/combat/Targetable.hpp:
#ifndef TARGETABLE_HPP
#define TARGETABLE_HPP

#include "../players/Ownable.hpp"

namespace combat{
  class Targetable : public players::Ownable { // ERROR
    public:
      Targetable(int playerID){}
      //Targetable(players::Player player);

      virtual Vec2 getPosition(){
        return Vec2();
      }
      virtual Vec2 getVelocity(){
        return Vec2();
      }
  };
}

#endif

我真的希望这是我缺少的一些愚蠢的语法。我什至试过

using players::Ownable;

但是 A) 污染了包含这个文件的文件，并且 B) 没有解决任何问题。有什么帮助吗？

编辑：GManNickG 明白了，它是 Headers.hpp 文件中的一个循环包含。谢谢！

4

2 回答 2

4

你有一个循环包含。

首先考虑包含守卫的目的：

// a.hpp
#ifndef A_HPP
#define A_HPP

// stuff

#endif

 

// b.hpp
#ifndef B_HPP
#define B_HPP

#include "a.hpp"

// stuff

#endif

 

// c.hpp
#ifndef C_HPP
#define C_HPP

#include "a.hpp"
#include "b.hpp"

// stuff

#endif

 

// x.cpp
#include "c.hpp"

包含c.hpp将最终包含a.hpp两次。第一次，守卫没有定义，一切正常，第二次守卫阻止重新定义。这就是我们想要的。

但是，当您有循环时，这不起作用。（它会阻止它，这很好，但它做得“太好了”，因为防护是在测试后立即定义的，这意味着标题的内容实际上还没有被处理）。考虑一下：

// a.hpp
#ifndef A_HPP
#define A_HPP

#include "c.hpp"

// stuff

#endif

 

// b.hpp
#ifndef B_HPP
#define B_HPP

#include "a.hpp"

// stuff

#endif

 

// c.hpp
#ifndef C_HPP
#define C_HPP

#include "b.hpp"

// stuff

#endif

 

// x.cpp
#include "c.hpp"

这与您所拥有的相似。x.cppincludes c.hpp，这是它第一次被包含，所以它定义了C_HPP. 然后c.hpp包括b.hpp，其中包括a.hpp。然后a.hppincludec.hpp并找到C_HPP已经定义的，所以 include 什么也不做。

假设a.hpp仍然设法编译（也就是说，c.hpp实际上并不需要），然后a.hpp完成，然后b.hpp完成，c.hpp最后在返回之前实际定义其内容x.cpp。

解决方案是尽量减少包含的标头数量。使用前向声明，最重要的是：不要使用“包含所有内容”标题！这些太可怕了。我怀疑就是这样Headers.hpp。

于 2012-04-17T19:03:41.617 回答
1

怎么样class Targetable : public ::players::Ownable { . . .？

::注意之前 的全局命名空间限定players。

于 2012-04-17T05:40:52.477 回答