Question

代码如下：

// with forward declaration: error C2653: 'B': is not a class or namespace name
// without forward declaration: error C2027: use of undefined type 'B'
struct B;

struct A {
    using size_t = int;
    typename B::size_t index;
};

struct B {
    using size_t = char;
    typename A::size_t index;
};

void main() {
    A a;
    B b;
}

A类和B类引用彼此的嵌套类型size_t。

但像class A;这样的前向声明只适用于在当前作用域或外部作用域中声明的类。

那么如何解决这个循环依赖而不改变代码的语义？就像使用前向声明解决更容易的情况一样，或者像java和c＃那样没有得到任何循环依赖问题？

P.S。

感谢Galik的建议，这个问题的原始例子

template <typename T>
class A {
    using iterator = T*;
    B<T>::iterator iter;
};

template <typename T>
class B {
    using iterator = T*;
    A<T>::iterator iter;
};

包含其他错误，例如iterator因私密而无法访问，typename之前需要A<T>::iterator。在修复bug之后，它将被成功编译。似乎泛型类和普通类之间存在一些差异，所以我在开头给出了一个例子（普通类），至少在Visual Studio 2015中无法编译。

Answer 1

typename之前需要B<T>::Iterator，因为B<T>是从属范围。

#include <string>
template<class T> class B;

template<class T>
class A {
public:
    using Iterator = T*;
private:
    typename B<T>::Iterator iter;
};

template<class T>
class B {
public:
    using Iterator = T*;
private:
    typename A<T>::Iterator iter;
};

int main()
{
    A<int> a;
    B<std::string> b;
}

Answer 2

我不确定OP想要回答的问题是什么此外，问题中的示例包含几个错误。

那说，这可能会解决。

您可以为两个类之一引入基类：

struct A_b {
    using size_t = int;
};

struct B {
    using size_t = char;
    A_b::size_t index;
};

struct A: A_b {
    B::size_t index;
};

int main() {
    A a;
    B b;
}

或者将其中一个转为模板类：

template<class T>
struct A_t {
    using size_t = int;
    typename T::size_t index;
};

struct B {
    using size_t = char;
    typename A_t<B>::size_t index;
};

using A = A_t<B>;

int main() {
    A a;
    B b;
}

依旧......

如何在C ++中解决嵌套类型的循环依赖？

2 个答案: