C++ 类转发声明导致类型不完整

我有以下代码：

class Node;

class Edge {
    public:
    //Edge(Node originnode,Node targetnode,int weight):OriginNode(originnode),TargetNode(targetnode),Weight(weight){};
    //~Edge(){};
    //Node getOriginNode() const { return OriginNode;};
    //Node getTargetNode() const { return TargetNode;};
    int getWeight() const { return Weight;};
    Node OriginNode;
    Node TargetNode;
    int Weight;
};

class Node{
    public:
    std::string getName();
    std::vector<Edge> getEdges();
};

类节点；
阶级边缘{
公众：
//边（Node originnode，Node targetnode，int-weight）：originnode（originnode），targetnode（targetnode），weight（weight）{}；
//~Edge（）{}；
//Node getOriginNode（）常量{return OriginNode；}；
//节点getTargetNode（）常量{return TargetNode；}；
int getWeight（）常量{return Weight；}；
节点起源节点；
节点目标节点；
整数权重；
};
类节点{
公众：
std:：string getName（）；
std:：vector getEdges（）；
};

---

当我试图编译时，编译器声称

OriginNode

和

TargetNode

的类型不完整。我已经向前声明了节点。如何解决此问题？

如果不提供

节点的完整定义，则无法解决此问题。您也可以将指针声明为成员：
Node*OriginNode

我建议你重新考虑一下你的设计——边缘真的有节点吗。例如，它对它拥有所有权吗？不能在多条边之间共享
节点
？另外，
节点
是否真的包含多条边
 如果不提供
节点
的完整定义，则无法执行此操作。您也可以将指针声明为成员：
Node*OriginNode

我建议你重新考虑一下你的设计——边缘真的有节点吗。例如，它对它拥有所有权吗？不能在多条边之间共享
节点
？另外，
节点
是否真的包含多条边
 使用boost:：container可以更改声明的顺序，因为它支持不完整类型的容器：

    class Edge;

class Node{
    public:
    std::string getName();
    boost::container::vector<Edge> getEdges();
};

class Edge {
    public:
    //Edge(Node originnode,Node targetnode,int weight):OriginNode(originnode),TargetNode(targetnode),Weight(weight){};
    //~Edge(){};
    //Node getOriginNode() const { return OriginNode;};
    //Node getTargetNode() const { return TargetNode;};
    int getWeight() const { return Weight;};
    Node OriginNode;
    Node TargetNode;
    int Weight;
};

类边缘；
类节点{
公众：
std:：string getName（）；
boost:：container:：vector getEdges（）；
};
阶级边缘{
公众：
//边（Node originnode，Node targetnode，int-weight）：originnode（originnode），targetnode（targetnode），weight（weight）{}；
//~Edge（）{}；
//Node getOriginNode（）常量{return OriginNode；}；
//节点getTargetNode（）常量{return TargetNode；}；
int getWeight（）常量{return Weight；}；
节点起源节点；
节点目标节点；
整数权重；
};

顺便问一下，为什么要在从节点获取边向量时返回边向量的值，为什么要将OriginNode和TargetNode的值存储在边中，您可以使用引用或指针（可能我错了，我不知道您的所有要求）.
使用boost:：container，您可以更改声明的顺序，因为它支持不完整类型的容器：

    class Edge;

class Node{
    public:
    std::string getName();
    boost::container::vector<Edge> getEdges();
};

class Edge {
    public:
    //Edge(Node originnode,Node targetnode,int weight):OriginNode(originnode),TargetNode(targetnode),Weight(weight){};
    //~Edge(){};
    //Node getOriginNode() const { return OriginNode;};
    //Node getTargetNode() const { return TargetNode;};
    int getWeight() const { return Weight;};
    Node OriginNode;
    Node TargetNode;
    int Weight;
};

类边缘；
类节点{
公众：
std:：string getName（）；
boost:：container:：vector getEdges（）；
};
阶级边缘{
公众：
//边（Node originnode，Node targetnode，int-weight）：originnode（originnode），targetnode（targetnode），weight（weight）{}；
//~Edge（）{}；
//Node getOriginNode（）常量{return OriginNode；}；
//节点getTargetNode（）常量{return TargetNode；}；
int getWeight（）常量{return Weight；}；
节点起源节点；
节点目标节点；
整数权重；
};

顺便问一下，为什么要在从节点获取边向量时返回边向量的值，以及为什么要将OriginNode和TargetNode的值存储在边中，您可以使用引用或指针（可能我错了，我不知道您的所有要求）。
您应该颠倒声明的顺序

class Edge;

class Node{
    public:
    std::string getName();
    std::vector<Edge> getEdges();
};

class Edge {
    public:
    //Edge(Node originnode,Node targetnode,int weight):OriginNode(originnode),TargetNode(targetnode),Weight(weight){};
    //~Edge(){};
    //Node getOriginNode() const { return OriginNode;};
    //Node getTargetNode() const { return TargetNode;};
    int getWeight() const { return Weight;};
    Node OriginNode;
    Node TargetNode;
    int Weight;
};

类边缘；
类节点{
公众：
std:：string getName（）；
std:：vector getEdges（）；
};
阶级边缘{
公众：
//边（Node originnode，Node targetnode，int-weight）：originnode（originnode），targetnode（targetnode），weight（weight）{}；
//~Edge（）{}；
//Node getOriginNode（）常量{return OriginNode；}；
//节点getTargetNode（）常量{return TargetNode；}；
int getWeight（）常量{return Weight；}；
节点起源节点；
节点目标节点；
整数权重；
};

然而，我认为课堂设计是非常糟糕的。节点是不应包含边向量的基本图元。为什么节点要控制容器？！容器是比节点更高级的泛化。因此，与Node相比，它应该放在更高的级别。
您应该颠倒声明的顺序

class Edge;

class Node{
    public:
    std::string getName();
    std::vector<Edge> getEdges();
};

class Edge {
    public:
    //Edge(Node originnode,Node targetnode,int weight):OriginNode(originnode),TargetNode(targetnode),Weight(weight){};
    //~Edge(){};
    //Node getOriginNode() const { return OriginNode;};
    //Node getTargetNode() const { return TargetNode;};
    int getWeight() const { return Weight;};
    Node OriginNode;
    Node TargetNode;
    int Weight;
};

类边缘；
类节点{
公众：
std:：string getName（）；
std:：vector getEdges（）；
};
阶级边缘{
公众：
//边（Node originnode，Node targetnode，int-weight）：originnode（originnode），targetnode（targetnode），weight（weight）{}；
//~Edge（）{}；
//Node getOriginNode（）常量{return OriginNode；}；
//节点getTargetNode（）常量{return TargetNode；}；
int getWeight（）常量{return Weight；}；
节点起源节点；
节点目标节点；
整数权重；
};

然而，我认为课堂设计是非常糟糕的。节点是不应包含边向量的基本图元。为什么节点要控制容器？！容器是比节点更高级的泛化。因此，它应该被放置在比节点更高的级别。
这只会编译为指针或节点引用到C++，你不能有两个类定义需要彼此定义。编译器的声明是正确的：<代码>节点< /C>是不完整的类型，当你使用在Edg/<代码>类中时定义。作为声明
std:：vector getEdges（）
不需要完整的类型
std:：vector
，您可以颠倒类定义的顺序。只需确保成员函数
getEdges
的定义在
Edge
类的定义之后。（这是没有意义的，但是，正如Luchian指出的）这只会编译，如果它是指向节点的指针或者是C++中的节点引用，则不能有两个类定义需要彼此定义。编译器的声明是正确的：<代码>节点< /C>是不完整的类型，当你使用