c++ - 在头文件与源文件中包含 #includes

Question

我喜欢把我所有的#includes 放在我的头文件中，然后只在我的源文件中包含我的源文件的头文件。什么是行业标准？我的方法有什么缺点吗？

Answer 1

通常，您只想将最少的必要包含放入类头文件中，因为使用该头文件的任何其他人都将被迫 #include他们所有人也是。在较大的项目中，这会导致构建速度变慢、依赖性问题和各种其他问题。
将头文件视为类的公共(public)接口(interface)。你不想让使用它的每个人都背负额外的依赖，除非他们是 必需能够使用该类。
将仅在类实现中需要的任何内容下移到源文件中。对于标题中使用的其他类，只有 #include如果您确实需要知道它们的大小或标题中的内容，它们的标题 - 任何其他内容和 forward declaration足够了。大多数情况下，您只需要#include您继承的类，以及其对象是您的类的值成员的类。
This page有一个很好的总结。 (以下复制以供引用)

C++ 头文件包含模式
即使在使用 C 编程时，大型软件项目也需要仔细的头文件管理。当开发人员转向 C++ 时，头文件管理变得更加复杂和耗时。在这里，我们展示了一些头文件包含模式，可以简化这项工作。
头文件包含规则
在这里，我们讨论简化头文件管理所需的 C++ 头文件包含的基本规则。
仅当前向声明无法完成这项工作时，才应包含头文件。
头文件的设计应该使头文件的包含顺序不重要。
这是通过确保 x.h 来实现的。是 x.cpp 中的第一个头文件
头文件包含机制应该能够容忍重复的头文件包含。
以下部分将通过示例来解释这些规则。
头文件包含示例
以下示例说明了不同类型的依赖项。假设一个类 A 的代码存储在 a.cpp和 a.h .a.h

#ifndef _a_h_included_
#define _a_h_included_
#include "abase.h"
#include "b.h"

// Forward Declarations
class C;
class D;

class A : public ABase
{
  B m_b;
  C *m_c;
  D *m_d;

public:
  void SetC(C *c);
  C *GetC() const;

  void ModifyD(D *d);
};
#endif

a.cpp

#include "a.h"
#include "d.h"

void A::SetC(C* c)
{
  m_c = c;
}

C* A::GetC() const
{
  return m_c;
}

void A::ModifyD(D* d)
{
  d->SetX(0);
  d->SetY(0);
  m_d = d;
}

文件包含分析
让我们从这个例子中涉及的类的角度来分析头文件的包含，即 ABase , A , B , C和 D .

A类基础: ABase是基类，所以需要类声明来完成类声明。编译器需要知道ABase的大小确定A的总大小.在这种情况下 abase.h应明确包含在 a.h 中.

B类:类(class)A包含类 B按值，所以需要类声明来完成类声明。编译器需要知道B的大小来确定A的总大小.在这种情况下 b.h应明确包含在 a.h 中.

C类 :Class C仅作为指针引用包含在内。 C的大小或实际内容对a.h不重要或 a.cpp .因此，a.h 中只包含了一个前向声明。 .请注意 c.h未包含在 a.h 中或 a.cpp .

D级 : 类(class) D在 a.h 中只是用作指针引用.因此，预先声明就足够了。但是a.cpp使用类 D实质上，它明确包括 d.h .

要点
仅当前向声明不起作用时才应包含头文件。不包括 c.h和 d.h类(class)的其他客户 A永远不用担心 c.h和 d.h除非他们按值使用 C 类和 D 类。 a.h已作为第一个头文件包含在 a.cpp 中这将确保 a.h不希望在 a.h 之前包含某个头文件.如 a.h已作为第一个文件收录，成功编译 a.cpp将确保 a.h不希望在 a.h 之前包含任何其他头文件.
如果所有类都遵循这一点，(即 x.cpp 总是包含 x.h 作为第一个 header )，将不依赖于头文件的包含。 a.h包括对符号 _a_h_included_ 的预处理器定义的检查.这使得它可以容忍 a.h 的重复包含.
循环依赖
类 X 之间存在循环依赖和 Y在下面的例子中。这种依赖是通过使用前向声明来处理的。
# x.h and y.h #

/* ====== x.h ====== */
// Forward declaration of Y for cyclic dependency
class Y;

class X 
{
    Y *m_y;
    ...
};

/* ====== y.h ====== */
// Forward declaration of X for cyclic dependency
class X;

class Y 
{
    X *m_x;
    ...
};