C++ 中的共存类

Posted 2023-02-22

【中文标题】C++ 中的共存类

【英文标题】：Co-existent classes in C++

【发布时间】：2013-06-21 17:21:35

【问题描述】：

我需要创建两个相互使用的类。

例如：

Class A 包含Class B 类型的对象，Class B 包含Class A 类型的对象

但是，当我编译时，会发生这种情况：“错误：ISO C++ 禁止声明没有类型的 'Map'”

我修改了我的类，将 Header (.h) 文件分开，但没有解决。

也许，这是一个基本问题，但我不知道在谷歌上搜索的关键字......

代码：

细胞.h：

Class Cell

public:
    Map *map;

地图.h：

Class Map

public:
    Cell *cell;

【问题讨论】：

“包含”是什么意思？显然，A 和 B 不能将彼此的实例作为成员...

是的，他们可以@OliCharlesworth ...

@IvanSeidel：他们绝对不能，因为那会导致无限递归。但是，它们可以指向或引用彼此实例的成员（例如通过map）。

您发布了代码链接，而不是代码。一个好的问题有一个简化版本的代码，它仍然演示了你想要讨论的问题。另见sscce.org。

@IvanSeidel 它们不能包含彼此的实例。他们能做的最好的事情就是持有指向其他实例的引用或指针。很不一样

【参考方案1】：

你想要前向声明和指针。

//a.h
class B; //forward declare than a class B, exist somewhere, although it is not completely defined.

class A
 map<string,B*> mapOfB;
;

//b.h
class A; //forward declare than a class A, exist somewhere, although it is not completely defined.
class B
 map<string,A*> mapOfA;

在您的 .cxx 中，您实际上会包含必要的标题

//a.cxx
#include "b.h"
A::A() /* do stuff with mapOfB */ 

//b.cxx
#include "a.h"
B::B() /* do stuff with mapOfA */ 

【讨论】：

共享指针在这里会是更好的选择，但要小心循环引用。

是的，但只是保持简单/简单，例如

啊，伙计们……这没什么大不了的。对于一个简单的例子来说太混乱了。 Plus 用户尚未指定 C++11 或 boost 的可用性...

【参考方案2】：

你的问题是你有递归包含。 Cell.h 包括 Map.h，其中包括 Cell.h。而不是像这样包含只是向前声明类：

在Cell.h:

class Map;

class Cell

    // ...

在Map.h:

class Cell;

class Map

    // ...

【参考方案3】：

如果class A 包含class B 并且class B 也包含class A，那么不，您不能这样做。

class B; // forward declaration of name only. Compiler does not know how much
         // space a B needs yet.

class A 
    private:
        B b; // fail because we don't know what a B is yet.
;

class B 
    private:
        A a;
;

即使这样可行，也无法构造任何一个实例。

B b; // allocates space for a B
     // which needs to allocate space for its A
     // which needs to allocate space for its B
     // which needs to allocate space for its A
     // on and on...

然而，它们可以包含彼此的指针（或引用）。

class B; // forward declaration tells the compiler to expect a B type.

class A 
    private:
        B* b; // only allocates space for a pointer which size is always
              // known regardless of type.

;

class B 
    private:
        A* a;
;