c – 由于类之间的循环依赖性而解决构建错误

我经常发现自己处于这样一种情况：我在C项目中面临多个编译/链接器错误,因为一些糟糕的设计决策(由其他人做出:))导致不同头文件中C类之间的循环依赖(也可能发生)在同一个文件中).但幸运的是(？)这种情况经常不足以让我在下次再次发生问题时记住这个问题的解决方案.

因此,为了便于将来回忆,我将发布一个代表性问题和解决方案.更好的解决方案当然是受欢迎的.

> A.h

class B;
class A
{
    int _val;
    B *_b;
public:

    A(int val)
        :_val(val)
    {
    }

    void SetB(B *b)
    {
        _b = b;
        _b->Print(); // COMPILER ERROR: C2027: use of undefined type 'B'
    }

    void Print()
    {
        cout<<"Type:A val="<<_val<<endl;
    }
};

> B.h.

#include "A.h"
class B
{
    double _val;
    A* _a;
public:

    B(double val)
        :_val(val)
    {
    }

    void SetA(A *a)
    {
        _a = a;
        _a->Print();
    }

    void Print()
    {
        cout<<"Type:B val="<<_val<<endl;
    }
};

> main.cpp

#include "B.h"
#include <iostream>

int main(int argc, char* argv[])
{
    A a(10);
    B b(3.14);
    a.Print();
    a.SetB(&b);
    b.Print();
    b.SetA(&a);
    return 0;
}

解决方法:

思考这个问题的方法是“像编译器一样思考”.

想象一下,你正在编写一个编译器.你看到这样的代码.

// file: A.h
class A {
  B _b;
};

// file: B.h
class B {
  A _a;
};

// file main.cc
#include "A.h"
#include "B.h"
int main(...) {
  A a;
}

当您编译.cc文件时(记住.cc而不是.h是编译单元),您需要为对象A分配空间.那么,那么多少空间呢？足够存放B！那么B的大小是多少？足够存储A！哎呀.

显然是一个必须打破的循环引用.

您可以通过允许编译器保留尽可能多的空间来解决它,因为它知道前端 – 指针和引用,例如,总是32或64位(取决于体系结构),因此如果您替换(任一)一个指针或参考,事情会很棒.假设我们在A中替换：

// file: A.h
class A {
  // both these are fine, so are various const versions of the same.
  B& _b_ref;
  B* _b_ptr;
};

现在事情变得更好了.有些. main()仍然说：

// file: main.cc
#include "A.h"  // <-- Houston, we have a problem

#include,对于所有范围和目的(如果您将预处理器取出)只需将文件复制到.cc中.真的,.cc看起来像：

// file: partially_pre_processed_main.cc
class A {
  B& _b_ref;
  B* _b_ptr;
};
#include "B.h"
int main (...) {
  A a;
}

你可以看到为什么编译器无法解决这个问题 – 它不知道B是什么 – 它以前从未见过这个符号.

所以让我们告诉编译器B.这被称为forward declaration,将在this answer进一步讨论.

// main.cc
class B;
#include "A.h"
#include "B.h"
int main (...) {
  A a;
}

这有效.这不是很好.但是在这一点上你应该了解循环引用问题以及我们做了什么来“修复”它,尽管修复很糟糕.

这个修复不好的原因是因为#include“A.h”的下一个人必须在他们可以使用它之前声明B并且会得到一个可怕的#include错误.那么让我们将声明转移到A.h本身.

// file: A.h
class B;
class A {
  B* _b; // or any of the other variants.
};

在B.h,此时,您可以直接#include“A.h”.

// file: B.h
#include "A.h"
class B {
  // note that this is cool because the compiler knows by this time
  // how much space A will need.
  A _a; 
}

HTH.

标签：c,compiler-errors,circular-dependency,c-faq
来源： https://codeday.me/bug/20190910/1802040.html