226

我最近陷入了这样的情况：

class A
{
public:
    typedef struct/class {…} B;
…
    C::D *someField;
}

class C
{
public:
    typedef struct/class {…} D;
…
    A::B *someField;
}

通常你可以声明一个类名：

class A;

但是不能前向声明嵌套类型，以下会导致编译错误。

class C::D;

有任何想法吗？

4

7 回答 7

254

你不能这样做，这是 C++ 语言中的一个漏洞。您必须至少取消嵌套其中一个嵌套类。

于 2009-06-04T15:23:10.313 回答
38 
class IDontControl
{
    class Nested
    {
        Nested(int i);
    };
};

我需要一个前向参考，例如：

class IDontControl::Nested; // But this doesn't work.

我的解决方法是：

class IDontControl_Nested; // Forward reference to distinct name.

稍后当我可以使用完整定义时：

#include <idontcontrol.h>

// I defined the forward ref like this:
class IDontControl_Nested : public IDontControl::Nested
{
    // Needed to make a forwarding constructor here
    IDontControl_Nested(int i) : Nested(i) { }
};

如果有复杂的构造函数或其他不能顺利继承的特殊成员函数，这种技术可能会比它的价值更麻烦。我可以想象某些模板魔法反应很糟糕。

但在我非常简单的情况下，它似乎有效。

于 2011-11-07T01:22:23.130 回答
5

如果你真的想避免#include 讨厌的头文件在你的头文件中，你可以这样做：

hpp 文件： 

class MyClass
{
public:
    template<typename ThrowAway>
    void doesStuff();
};

.cpp 文件

#include "MyClass.hpp"
#include "Annoying-3rd-party.hpp"

template<> void MyClass::doesStuff<This::Is::An::Embedded::Type>()
{
    // ...
}

但是之后：

  1. 您必须在调用时指定嵌入类型（特别是如果您的函数不采用嵌入类型的任何参数）
  2. 你的函数不能是虚拟的（因为它是一个模板）

所以，是的，权衡...

于 2012-04-16T12:56:30.987 回答
1

我不会将此称为答案，但仍然是一个有趣的发现：如果您在名为 C 的命名空间中重复声明结构，一切都很好（至少在 gcc 中）。当找到 C 的类定义时，它似乎默默地覆盖了 namspace C。

namespace C {
    typedef struct {} D;
}

class A
{
public:
 typedef struct/class {...} B;
...
C::D *someField;
}

class C
{
public:
   typedef struct/class {...} D;
...
   A::B *someField;
}
于 2009-06-04T15:48:03.347 回答
1

如果你有权限修改C类和D类的源代码，那么你可以把D类单独拿出来，在C类中输入它的同义词：

class CD {

};

class C {
public:

    using D = CD;

};

class CD;
于 2019-04-22T07:46:59.307 回答
0

这将是一种解决方法（至少对于问题中描述的问题 - 不是针对实际问题，即当无法控制 的定义时C）：

class C_base {
public:
    class D { }; // definition of C::D
    // can also just be forward declared, if it needs members of A or A::B
};
class A {
public:
    class B { };
    C_base::D *someField; // need to call it C_base::D here
};
class C : public C_base { // inherits C_base::D
public:
    // Danger: Do not redeclare class D here!!
    // Depending on your compiler flags, you may not even get a warning
    // class D { };
    A::B *someField;
};

int main() {
    A a;
    C::D * test = a.someField; // here it can be called C::D
}
于 2017-06-03T02:15:59.617 回答
0

这可以通过将外部类声明为命名空间来完成。

示例：我们必须在 others_a.h 中使用嵌套类 others::A::Nested，这是我们无法控制的。

其他_a.h

namespace others {
struct A {
    struct Nested {
        Nested(int i) :i(i) {}
        int i{};
        void print() const { std::cout << i << std::endl; }
    };
};
}

my_class.h

#ifndef MY_CLASS_CPP
// A is actually a class
namespace others { namespace A { class Nested; } }
#endif

class MyClass {
public:
    MyClass(int i);
    ~MyClass();
    void print() const;
private:
    std::unique_ptr<others::A::Nested> _aNested;
};

my_class.cpp

#include "others_a.h"
#define MY_CLASS_CPP // Must before include my_class.h
#include "my_class.h"

MyClass::MyClass(int i) :
    _aNested(std::make_unique<others::A::Nested>(i)) {}
MyClass::~MyClass() {}
void MyClass::print() const {
    _aNested->print();
}
于 2018-05-31T07:46:28.953 回答