Question

一个继承了以自己为模板入参的类，C++是如何构造的

template<typename T>
class A
{...}

class B:public A<B>
{...}
B类是如何构造的？

Answer 1

#include "stdafx.h"
#include <iostream>
using namespace std;

template<typename T>
class A
{
public:
	A() { cout << "A construct()" << endl; ++m_nCounter; }
	~A() { cout << "A desstruct()" << endl; --m_nCounter; }

public:
	void printCount() { cout << m_nCounter << endl; }

private:
	static int m_nCounter;
};

template <typename T>
int A<T>::m_nCounter = 0;

class B:public A<B>
{
public:
	B() { cout << "B construct()" << endl; }
	~B() { cout << "B desstruct()" << endl; }

public:
	void printCountOfB() { cout << "Count of B: "; printCount(); }
};

class C:public A<C>
{
public:
	C() { cout << "C construct()" << endl; }
	~C() { cout << "C desstruct()" << endl; }

public:
	void printCountOfC() { cout << "Count of C: "; printCount(); }
};


int main()
{
	/// A先于B构造
 	B* pB1 = new B;

	pB1->printCountOfB();

	B* pB2 = new B;

	pB2->printCountOfB();

	/// B先于A析构
	delete pB2;

	pB1->printCountOfB();

	C* pC1 = new C;
	C* pC2 = new C;
	C* pC3 = new C;

	/// 两个不同的类，其Counter实例互不干扰
	pB1->printCountOfB();
	pC1->printCountOfC();

	delete pB1;
	delete pC1;
	delete pC2;
	delete pC3;

	return 0;
}

运行一次就知道构造顺序了。

这是一种取巧的编程方法，用于多个类共享同一功能。

他们说编译不了是对的。用下面的例子，不要在模板类中直接声明类的实例。

template<typename T>
class A
{
public:
	A() {}
	~A() {}

public:
	T m_InstanceOfT;
};

class B:public A<B>
{
public:
	B() {}
	~B() {}
};

int main()
{
	return 0;
}

Answer 2

我记得设计模式里面有种模式是这种，不过如果是T组合进去的话，估计构造会陷入无限递归，T以指针形式存在的话，就直接创建4字节指针就行了，先构造A再构造B。

Answer 3

先调用A<B>的构造函数，再调用B的构造函数。所以如果A<B>中含有B类型的成员变量，就会无限递归，编译不了。

Answer 4

很不懂你的意思啊？详细点？

追问

B继承了以自己为模板参数的模板类A ，我想知道B类的构造过程

追答

这与模板没啥关系，与
以自己为模板入参
也没啥关系吧

构造顺序跟普通类没啥区别吧，还是 父类(A) ->子类（B）-》本身类（B）

追问

我只是有点怀疑，在B类没有构造完成的时候，使用B类作为模板参数，对模板类是否有影响。
会不会产生，模板类寻找模板参数类型B，B为构造完成，这种情况。试验下来B还是构造完成了，模板类的继承和模板参数没有关系吗？

追答

其实这就相当于B类有个成员是B的对象。构造过程与模板没啥关系的

看LX的，说的不错啊

建议采纳他的，他指出了关键问题所在！

追问

编译不了的理论，明显是错误的！不信你可以自己编译一下。

我想知道的也是，为什么递归这种理论，没有在这个构造过程实现。

追答

template<typename T>
class A
{
    private:
        T subdata;
};

class B:public A<B>
{
};

你再试试，你没理解他的意思啊