C++ c++；嵌套模板类工作？

我有以下示例TestC是一个模板类。类测试使用一个模板类作为模板，并且有一个特殊的成员，它是嵌套实例化a>。然而，编译器对这一点表示不满。这是违法的吗？或者如何纠正它

提前谢谢

#include <iostream>
using namespace std;

template <class A>
class TestC {
    public:
    TestC(double a = 100.0) : a_(a) {};
    A member_;
    double a_;
};

template <template <class> class A>
class Test {
    public:
    Test(A<Test<A> > member = A<Test<A> >() );
    A<Test<A> > member_;
};

int main() {
    TestC< Test<TestC> > a(10.0);
    return 0;
}

班级

template <template <class> class A>
class Test {
    public:
    Test(A<Test<A> > member = A<Test<A> >() );
    A<Test<A> > member_;
    //^^^^^^^ this requires Test to be defined completely.
};

在定义依赖于完整类定义的成员变量之前，

类测试的定义还没有结束

在常规类中，可以使用指向该类的指针作为成员

class Test
{
   Test* member_;
};

您可以使用类模板执行类似的操作。以下是成功构建的程序

#include <iostream>
using namespace std;

template <class A>
class TestC {
    public:
    TestC(double a = 100.0) : a_(a) {}
    A member_;
    double a_;
};

template <template <class> class A>
class Test {
    public:
    Test() {}
    A<Test<A>* > member_;
};

int main() {
    TestC< Test<TestC> > a;

    // type of a is TestC< Test<TestC> >
    // It has a member member_.
    // type of a.member_ is Test<TestC>
    // a.member_ has a member member_
    // type of a.member_.member_ is TestC<Test<TestC>*>
    // a.member_.member_ has a member whose type is Test<TestC>*
    // You can assign nullptr to it.
    a.member_.member_.member_ = nullptr;

    // Or you can assign to it a pointer to an object allocated from the heap.
    a.member_.member_.member_ = new Test<TestC>;

    return 0;
}

#包括
使用名称空间std；
模板
类TestC{
公众：
TestC（double a=100.0）：a_u（a）{}
一名成员；
双a；
};
模板
课堂测试{
公众：
Test（）{}
一名成员；
};
int main（）{
TestCa；
//a的类型是TestC
//它有一个成员。
//a.member的类型为测试
//a.member有一个成员_
//a.member的类型是TestC
//a.member_uu.member_uu有一个类型为Test的成员*
//您可以将nullptr分配给它。
a、 成员\成员\成员\成员=空PTR；
//或者，您可以为它指定一个指向从堆中分配的对象的指针。
a、 成员\成员\成员\成员\新测试；
返回0；
}
我猜你的意思是
TestCa，目前您正在声明一个名为
a
的函数；我想我正在构造一个TestC的对象，仍然是错误的。谢谢。然而，改变指针不是我能做的。
class Test
{
   Test* member_;
};

#include <iostream>
using namespace std;

template <class A>
class TestC {
    public:
    TestC(double a = 100.0) : a_(a) {}
    A member_;
    double a_;
};

template <template <class> class A>
class Test {
    public:
    Test() {}
    A<Test<A>* > member_;
};

int main() {
    TestC< Test<TestC> > a;

    // type of a is TestC< Test<TestC> >
    // It has a member member_.
    // type of a.member_ is Test<TestC>
    // a.member_ has a member member_
    // type of a.member_.member_ is TestC<Test<TestC>*>
    // a.member_.member_ has a member whose type is Test<TestC>*
    // You can assign nullptr to it.
    a.member_.member_.member_ = nullptr;

    // Or you can assign to it a pointer to an object allocated from the heap.
    a.member_.member_.member_ = new Test<TestC>;

    return 0;
}