Question

我有这样的情况

在文件GameServer.h中：

class ServerGameStruct; //I can't simply include ServerGameStruct.h
                        // because of cyclic dependency
class GameServer {
public:
    class Client { };
private:
    ServerGameStruct gameStructure_;
}

并在文件ServerGameStruct.h中

#include "GameServer.h"

class ServerGameStruct {
public:
    typedef GameServer::Client Client;
    // some method which use type Client *
    // no class members with type Client 
}

编译后我得到GameServer :: gameStructure_使用未定义类GameServerStruct的错误。

如何解决那种头的循环依赖？

Answer 1

最简单的解决方案是使gameStructure_成为指针：

std::unique_ptr<ServerGameStruct> gameStructure_;

原因是指向类的指针不需要声明的类的完整定义。当你声明一个类的直接实例时，就像你的代码一样，那么你需要完整的类定义。

您也可以将其作为参考，但是您必须在GameServer构造函数中对其进行初始化。

Answer 2

使用指针

ServerGameStruct* gameStructure_;

在这种情况下，您需要手动处理ServerGameStruct的生命周期。智能指针可以帮助你做到这一点

Answer 3

您需要使gameStructure_成为（智能）指针或引用，因此不需要其类型定义。如果使用指针，那么在cpp文件中你需要一个析构函数，即使它是空的，所以你（或者最好是你的智能指针）可以删除完整的类型。

Answer 4

另一种方法是引入抽象类型，例如AbstractGameClient。此类型可以提供界面ServerGameStruct需求，然后GameServer::Client将派生自AbstractGameClient。举例说明：

AbstractGameClient.h

class AbstractGameClient {
protected:
  AbstractGameClient();
  virtual ~AbstractGameClient();
public:
  void somePublicMember() const;
  virtual void somePublicMemberTheSubclassMustSupply() const = 0;
};

GameServer.h

class GameServer {
public:
    class Client : public AbstractGameClient {
      virtual void somePublicMemberTheSubclassMustSupply() const { ... }
      ...
    };
private:
    ServerGameStruct gameStructure_;
};

ServerGameStruct.h

#include "AbstractGameClient.h" // << or just a forward of AbstractGameClient,
                                //    then use AbstractGameClient in the *.cpp

class ServerGameStruct {
public:
  void something(AbstractGameClient& pGameClient) {
    pGameClient.somePublicMember();
    pGameClient.somePublicMemberTheSubclassMustSupply();
  }
};

标头与typedef之间的循环依赖关系

4 个答案: