当您不想 #include 时转发声明的替代方案

Question

我通常几乎不假思索地使用前向声明，这样我就不必包含标头。 此示例中的一些内容：

//-----------------------
// foo.h
//-----------------------
class foo
{
   foo();
   ~foo();
};


//-----------------------
// bar.h
//-----------------------

class foo; // forward declaration

class bar
{
   bar();
   ~bar();

   foo* foo_pointer;
};

一些开发人员喜欢使用此方法来避免包含圈问题。 我宁愿使用它来最大限度地减少广泛包含层次结构的开销，这是物理设计的重要组成部分（特别是对于大型项目）。

然而，在某些情况下，我真的很喜欢将成员声明为普通对象而不是指针，以从自动构造/销毁机制中受益。 这导致了无法再使用前向声明的问题，因为编译器在这种情况下需要类定义，例如：

//-----------------------
// foo.h
//-----------------------
class foo
{
   foo();
   ~foo();
};


//-----------------------
// bar.h
//-----------------------

class foo;       // Not enough given the way we declare "foo_object"..
#include "foo.h" // ..instead this is required

class bar
{
   bar();
   ~bar();

   foo foo_object;
};

所以，如果有人知道可以在这里使用的替代语言构造，我会很高兴，这样我就可以如示例所示声明“foo_object”，但不包含其标头。

问候

/罗伯特

Answer 1

你不能。 编译器在声明类时需要知道对象的大小。

引用是一种替代方案，尽管它们必须在构造时实例化，因此它并不总是可行。

另一种选择是智能指针，但我认为从技术上讲这仍然是一个指针。

不过，最好知道为什么您不想使用指针来建议其他构造......

Answer 2

只需使用智能指针 - 在这种情况下您甚至可以使用 auto_ptr 。

//-----------------------
// bar.h
//-----------------------

#include <memory>
class foo;       // Not enough given the way we declare "foo_object"..

class bar
{
public:
   bar();
   ~bar();

   foo &foo_object() { return *foo_ptr; }
   const foo &foo_object() const { return *foo_ptr; }

private:
   auto_ptr<foo> foo_ptr;
};

您可以获得自动内存管理的所有好处，而无需了解 bar.h 中 foo 的任何信息。 请参阅包装指针数据成员了解 Herb Sutter 的建议。

如果您确实希望默认构造自动发生，请尝试以下操作：

#include <iostream>
using namespace std;

class Foo;

template <typename T>
class DefaultConstuctorPtr
{
    T *ptr;
    void operator =(const DefaultConstuctorPtr &);
    DefaultConstuctorPtr(const DefaultConstuctorPtr &);

public:
    DefaultConstuctorPtr() : ptr(new T()) {}
    ~DefaultConstuctorPtr() { delete ptr; }

    T *operator *() { return ptr; }
    const T *operator *() const { return ptr; }
};

class Bar
{
    DefaultConstuctorPtr<Foo> foo_ptr;
public:
    Bar() {} // The compiler should really need Foo() to be defined here?
};

class Foo
{
public:
    Foo () { cout << "Constructing foo"; }
};

int main()
{
    Bar bar;
}

Answer 3

你想要的东西在C++中是做不到的。 为了生成对象的代码，编译器需要知道其类需要多少存储空间。 为了知道这一点，它必须知道类的每个成员需要多少存储空间。

如果要创建一个具有 foo 类型成员的 bar 类型的类，编译器必须知道 foo 有多大。 它知道这一点的唯一方法是它是否具有可用的 foo 定义（通过#include）。 否则，您唯一的选择是使用 foo 的前向声明和指针或引用，而不是实际的 foo 对象。

Answer 4

正如其他人所说，你不能这样做，因为他们也说过:)然后你说你不想关心包含它们的类中的成员构造/销毁。 您可以为此使用模板。

template<typename Type>
struct member {
    boost::shared_ptr<Type> ptr;
    member(): ptr(new Type) { }
};

struct foo;
struct bar {
    bar();
    ~bar();

    // automatic management for m
    member<foo> m;
};

我认为代码是不言自明的。 如果出现任何问题，请烦我。

Answer 5

没有办法解决这个问题。

最好的办法是限制包含的内容，但必须将文件包含在类声明中。 您可以将类声明拆分为一个单独的标头，希望该标头不包含任何其他内容。 那么是的，您必须有一个#include，但您仍然保持包含层次结构有些浅。 毕竟，包含一个文件很便宜，只有当层次结构延伸到数百或数千个文件时，它才会开始受到伤害......；）

Answer 6

几乎您唯一能做的就是通过 使用 pImpl 习惯用法，这样当您包含 foo.h 时，您只包含 foo 的接口。

您无法避免包含 foo.h，但您可以使其尽可能便宜。 您养成的使用前向声明而不是 #inlcudes 的习惯使您在这条道路上走得很好。

Answer 7

如果您能够使用引用，则可以保留相同的 use 语法。 但是，您的引用必须立即在构造函数中初始化，因此您的构造函数绝对必须定义为外线。 （您还需要在析构函数中释放该对象。）

// bar.h
class foo;

class bar {
    foo& foo_;

public:
    bar();
    ~bar();
};

// bar.cc
bar::bar() : foo_(*new foo)
{
    // ...
}

bar::~bar()
{
    // ...
    delete &foo_;
}

您的情况可能会有所不同。 :-)

Answer 8

您可以使用自定义的“智能指针”类来自动创建和销毁实例。 这将实现您所追求的自动构建和销毁。

为了防止需要另一个 #include，您可以在项目的前缀标头中包含此 myAuto 类，或者您可以将其复制并粘贴到每个标头中（不是一个好主意，但它可以工作） ）。

template<class T>
class myAuto
{
    private:
        T * obj;

    public:
        myAuto() : obj(new T) {  }
        ~myAuto() { delete obj; }
        T& object() { return *obj; }
        T* operator ->() { return obj; }
};

以下是您将如何使用它：

// foo.h:
class foo
{
    public:
        foo();
        ~foo();
        void some_foo_func();
};

//bar.h:
class foo;
class bar
{
    public:
       bar();
       ~bar();
       myAuto<foo> foo_object;
};

//main.cc:
#include "foo.h"
#include "bar.h"

int main()
{
    bar a_bar;

    a_bar.foo_object->some_foo_func();

    return 0;
}

Answer 9

您还可以使用 pImpl 习惯用法，例如：

//-----------------------
// foo.h
//-----------------------
class foo
{
    foo();
    ~foo();
};


//-----------------------
// bar.h
//-----------------------

class foo;

class bar
{
private:
    struct impl;
    boost::shared_ptr<impl> impl_;
public:
    bar();

    const foo& get_foo() const;
};

//-----------------------
// bar.cpp
//-----------------------
#include "bar.h"
#include "foo.h"

struct bar::impl
{
    foo foo_object;
    ...
}

bar::bar() :
impl_(new impl)
{
}

const foo& bar::get_foo() const
{
    return impl_->foo_object;
}

您仍然可以获得前向声明的好处，而且还隐藏了您的私有实现。 对 bar 实现的更改不一定需要编译 #include bar.h 的所有源文件。 实现结构本身是独立于 .cpp 文件中的，在这里您可以根据自己的喜好声明对象。

由于 pImpl 本身，您的性能受到了较小的影响，但根据应用程序，这可能不是什么大问题。

我已经在大型项目中使用了 pImpl 习惯用法，它对编译时间产生了很大的影响。 遗憾的是，该语言无法处理真正的私有实现，但你已经拥有了。

Answer 10

关联两个对象实际上只有三种选择。
您已经发现了两个：将 Foo 嵌入到 Bar 中，或者将 Foo 放在堆上并将 Foo* 放入 Bar 中。 第一个要求在定义 Bar 类之前先定义 Foo 类； 第二个只需要您转发声明类 Foo。

第三个选项确实存在，我只提到它是因为您在问题中明确排除了前面的两个选项。 您可以（在您的 .cpp 中）创建静态 std::map。 在每个 Bar 构造函数中，您都将 Foo 添加到此映射，并以 this 为键。 然后，每个 bar 成员都可以通过在地图中查找 this 来找到关联的 Foo。 Bar::~Bar 将调用 erase(this) 来销毁 Foo。

虽然这使 sizeof(Bar) 保持不变，但实际内存使用量比在 Bar 中包含 Foo* 更高。 不过，如果二进制兼容性是一个紧迫的问题，您仍然可以这样做。