Question

假设我有2个模板类，每个模板类都有一个指向另一个的模板;

template <typename T>
class A;

template <typename T>
class B;

template <typename T>
class A
{
  B<A>* p;
};

template <typename T>
class B
{
  A<B>* p;
};

我现在如何实例化这些类？我不能简单地运行A<B>，因为B不是类型（它是模板类型）。

A和B的实例在不同的线程中运行，并且具有相当大的状态和功能，因此从彼此继承它们并在每个类中复制它们的功能不是一个可行的选择。

如何解决这个问题并使这些类型保持彼此的指针/引用？

Answer 1

如何解决这个问题并使这些类型保持彼此的指针/引用？

这很乏味但你可以做到。

template <typename T>
struct A;

template <typename T>
struct B;

template <typename T>
struct A
{
   A() : p(nullptr) {}
   A(B<A>* ptr) : p(ptr) {}
   B<A>* p;
};

template <typename T>
struct B
{
   B() : p(nullptr) {}
   B(A<B>* ptr) : p(ptr) {}
   A<B>* p;
};

int main()
{
    A<B<int>>* a2Ptr = new A<B<int>>();
    B<A<int>>* b2Ptr = new B<A<int>>();

    A<int>* a1Ptr = new A<int>(b2Ptr);
    B<int>* b1Ptr = new B<int>(a2Ptr);
}

您可以构建更多级别的嵌套，但具有最深嵌套级别的对象必须具有nullptr成员变量。

int main()
{
    // This is conceptual, pseudo code, not compilable code
    // with N levels of nesting.
    // Member variable p is nullptr
    A<B< ...A<int>> ...>* aNPtr = new A<B< ...A<int>> ...>();
    B<A< ...B<int>> ...>* bNPtr = new B<A< ...B<int>> ...>();

    // This is conceptual, pseudo code, not compilable code
    // with N-1 levels of nesting.
    // Member variable p is non-nullptr
    A<B< ...A<int>> ...>* aMPtr = new A<B< ...A<int>> ...>(bNPtr);
    B<A< ...B<int>> ...>* bMPtr = new B<A< ...B<int>> ...>(aNPtr);

    A<B<A<int>>>* a3Ptr = new A<B<A<int>>>(b4Ptr);
    B<A<B<int>>>* b3Ptr = new B<A<B<int>>>(a4Ptr);

    A<B<int>>* a2Ptr = new A<B<int>>(b3Ptr);
    B<A<int>>* b2Ptr = new B<A<int>>(a3Ptr);

    A<int>* a1Ptr = new A<int>(b2Ptr);
    B<int>* b1Ptr = new B<int>(a2Ptr);
}

模板类可以指向彼此的实例吗？

1 个答案: