Question

我正在尝试生成一些类的头文件，这些类是根据我用IDA反汇编后的类重建的。但是由于循环依赖性，我遇到了编译错误。对于常规类，我通过在一个单独的文件中声明它们（作为第一个文件）来解决它。问题是我无法在没有定义外部类的情况下声明内部类。

类结构示例：

A级：

#include "B.h"

class A {

public:
    class Nested {
    public:
        void foo(B::Nested &foo);
    };
};

B级：

#include "A.h"

class B {

public:
    class Nested {
    public:
        void foo(A::Nested &foo);
    };
};

Answer 1

使用模板。

    class A {
public:
    class Nested {
    public: 
        template<class B>
        void foo(typename B:: Nested &fo);
    };
};

class B {
public:
    class Nested {
    public: 
        template<class A>
        void foo(typename A:: Nested &fo);
    };
};

template<>
void A::Nested::foo<B>(B::Nested & fo){
}

template<>
void B::Nested::foo<A>(A::Nested & fo){
}

例如（此处模板已上移，因此不必在每次函数调用时都指定类型。）

#include <iostream>

class A {
public:
   template <class B>
   class Nested {
    public: 
        std::string name() const { return "a"; }

        void foo(typename B:: template Nested<A> &fo);
    };
};

class B {
public:
    template <class A>
    class Nested  {
    public: 
        std::string name() const { return "b"; }

        void foo(typename A:: template Nested<B> &fo);
    };
};

template<>
void A::Nested<B>::foo(B::Nested<A> & fo){
    std::cout << "A::Nested " << fo.name() << '\n';
}

template<>
void B::Nested<A>::foo(A::Nested<B> & fo){
    std::cout << "B::Nested " << fo.name() << '\n';
}

int main()
    {
        A::Nested<B> a;
        B::Nested<A> b;
        a.foo(b);
        b.foo(a);
    }

Answer 2

您可以在Nested和A中向前声明B，然后再进行定义。

a.h

class A {
public:
    class Nested;
};

B.h

class B {
public:
    class Nested;
};

嵌套.h

#include "A.h"
#include "B.h"

class A::Nested {
public:
    void foo(B::Nested &foo);
};

class B::Nested {
public:
    void foo(A::Nested &foo);
};

Answer 3

编译器读取文件时，它需要声明的实体。

您可以向前声明该类，但是会缺少嵌套参数类型。

您可以做的是创建第三个类，该类打破循环依赖关系并继承到您的嵌套类：

IterableOnce

现在在您的A嵌套类中使用此基础：

class NestedBase {
};

在您的B嵌套类中也是如此：

#include "NestedBase.h"

class A {

public:
    class Nested : public NestedBase {
    public:
        void foo(NestedBase &foo);
    };
};

现在在方法实现中使用#include "NestedBase.h" class B { public: class Nested : public NestedBase { public: void foo(NestedBase &foo); }; };，您可以将它们转换为所需的类型，并访问您在嵌套类中声明的内容。

dynamic_cast

嵌套类的C ++循环依赖

3 个答案: