c++标题保持理智

Question

在使用 C++ 编码时，我似乎遇到的最大问题是，您必须先声明一个类，然后才能引用它。假设我有两个像这样的头文件...

Header1.h

#include "Header2.h"
#include <deque>
#include <string>
#include <iostream>
using namespace std;
class HelloPackage;
class Hello
{
public:
    string Message;
    HelloPackage * Package;
    Hello():Message("")
    {

    }
    Hello(string message, HelloPackage * pack)
    {
        Message = message;
        Package = pack;
    }
    void Execute()
    {
        cout << Message << endl;
        //HelloPackage->NothingReally doesn't exist.
        //this is the issue essentially
        Package->NothingReally(8);
    }
};

Header2.h

#include "Header1.h"
#include <deque>
#include <string>
#include <iostream>
using namespace std;
class HelloPackage
{
public:
    deque<Hello> Hellos;
    HelloPackage()
    {
        Hellos = deque<Hello>();
    }
    int AddHello(string Message)
    {
        Hellos.push_back(Hello(Message,this));
    }
    void ExecuteAll()
    {
        for each(Hello h in Hellos)
            h.Execute();
    }
    int NothingReally(int y)
    {
        int a = 0;
        a += 1;
        return a + y;
    }
}

我想知道的是，是否有任何优雅的解决方案来处理这些问题？在 C# 和 Java 中，您不受这种“线性”编译的限制。

Answer 1

1. 使用标头包含防护，“#ifndef / #define / #endif”或“#pragma Once”
2. 将代码放在 .cpp 中，而不是内联在标头中
3. ？？？
4. 利润

这对您有用的原因是，如果您愿意，您可以使用要引用的类的前向声明，而不包含该文件。

Answer 2

1. 您缺少包含防护，
2. 为什么要在标头中定义方法？

除了代码中的这些问题之外，回答您的问题：正常方法是转发声明类 - 不要在标头中包含标头（除非必须这样做）。

Answer 3

如果你遵循一些基本规则，那就一点也不尴尬了。但与 Java 或 C# 相比，您必须自己遵循这些规则，编译器和/或语言规范不会强制执行。

其他答案已经指出了这一点，但我将在这里回顾一下，以便您将其放在一个地方：

1. 使用 包括守卫。它们确保您的标头（以及您的类定义）仅包含一次。

2. 通常，您需要将方法的声明和实现分开。这使得头文件更具可重用性，并且会减少编译时间，因为头文件通常需要比 CPP（即实现）文件更少的 #include。

3. 在标头中，使用前向声明而不是包含。仅当您仅使用相应类型的名称，但不需要知道任何“内部结构”时，这才有可能。原因是前向声明只是告诉编译器某个名称存在，而不是它包含的内容。

   这是 Bar 类的前向声明：

   类栏；
   
   类 Foo {
       无效foooh（酒吧* b）；
   };
   

   在这里，编译器会知道某个地方有一个 Bar，但它不知道它有哪些成员。

4. 仅在 CPP 文件中使用“using namespace xyz”，而不是在标头中。

好吧，这是您的示例代码，经过修改以满足这些规则。我只显示Hello类，HelloPackage将相应地分为头文件和CPP文件。

Hello.h （在您的示例中是 Header1.h）

#include <string>

class HelloPackage;
class Hello
{
public:
    Hello();
    Hello(std::string message, HelloPackage * pack);
    void Execute();

private:
    string Message;
    HelloPackage * Package;
};

Hello.cpp

#include "Hello.h"

#include "HelloPackage.h"

using namespace std;

Hello::Hello() : Message("")
{}

Hello::Hello(string message, HelloPackage * pack)
{
    Message = message;
    Package = pack;
}

void Hello::Execute()
{
    cout << Message << endl;
    // Now accessing NothingReally works!
    Package->NothingReally(8);
}

可能出现的一个问题是为什么需要包含字符串。你不能也直接声明字符串类吗？

不同之处在于您使用字符串作为嵌入成员，而不使用指向字符串的指针。这没问题，但它强制您使用 #include，因为编译器必须知道 Hello 类中的字符串实例需要多少空间。