我最近陷入了这样的情况:
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;
有任何想法吗?
我最近陷入了这样的情况:
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;
有任何想法吗?
你不能这样做,这是 C++ 语言中的一个漏洞。您必须至少取消嵌套其中一个嵌套类。
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) { }
};
如果有复杂的构造函数或其他不能顺利继承的特殊成员函数,这种技术可能会比它的价值更麻烦。我可以想象某些模板魔法反应很糟糕。
但在我非常简单的情况下,它似乎有效。
如果你真的想避免#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>()
{
// ...
}
但是之后:
所以,是的,权衡...
我不会将此称为答案,但仍然是一个有趣的发现:如果您在名为 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;
}
如果你有权限修改C类和D类的源代码,那么你可以把D类单独拿出来,在C类中输入它的同义词:
class CD {
};
class C {
public:
using D = CD;
};
class CD;
这将是一种解决方法(至少对于问题中描述的问题 - 不是针对实际问题,即当无法控制 的定义时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
}
这可以通过将外部类声明为命名空间来完成。
示例:我们必须在 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();
}