Question

我有一些在同一个文件中按顺序声明的类，但是，我希望它们能够相互引用。但是，类只能由它们之上的类声明。

我可以通过将它们分成不同的.h文件并根据需要将它们#include彼此分开来实现吗？或者这可以在将它们保存在同一文件中时完成

或者这是不好的做法？

（具体来说，我有一个A类实例需要跟踪不同类型的B类的多个实例，这些实例可能尝试与A类交互，没有特定的顺序;我需要保留反馈特定于B类试图与A类的一个实例进行对话...）

Answer 1

只要“引用”你的意思是指针，这应该有效：

class Foo;

class Bar {
  Foo* p;
};

class Foo {
  Bar* p;
};

Answer 2

您可以转发声明类，然后在文件中定义它们：

class A;

class B
{
    // As pointed out by syam this will have to be an A* or A& not just of type A.
    // If this line were:
    // A myA
    // The compiler gives error: field ‘myA’ has incomplete type
    A* myA;
};

class A {};

如果您想要从A中的方法访问B中的方法或属性，那么您必须确保在A的定义之后定义这些方法。

class A;

class B
{
    A& myA;
    int getAValue(void); // Can't use myA.value here as value is not declared yet.
};

class A
{
public:
    int value;
};

int B::getAValue(void) {return myA.value;}

Answer 3

您可以使用前向声明。

Answer 4

你甚至可以引入一个自引用指针：

class Foo {
    Foo* parent;
};

Answer 5

我会做这样的事情：

class A;

class B {
private:
    A *parent;
public:
    B() {
        this->parent = 0;
    }
    B(A *parent) {
        this->parent = parent;
    }
    void erase();
};

class A {
private:
    std::vector<B> members;
public:
    void add(const B &x) { members.push_back(x); }
    B *getArray() {
        B *rv = new B[members.size()];
        for(int i=0;i<members.size();++i)
            rv[i] = members[i];
        return rv;
    }
    void remove(B *member) {
        for(std::vector<B>::iterator i = members.begin(); i != members.end(); ++i) {
            if(&(*i) == member) {
                members.erase(i);
                break;
            }
        }
    }
};

void B::erase() {
    if(parent)
        parent->remove(this);
}

关键点：

我先声明B，所以B可以使用A的实例。
我已经向前声明了A，所以编译器知道它是一个有效的类。这允许B保持指向B实例的指针。
但是，B中引用A的任何方法都需要在 A的定义之后出现。否则，您将获得error: invalid use of incomplete type ‘struct A’或类似的。

类可以互相引用吗？

5 个答案: