类模版02

1.声明

template<class T1, class T2,......,class Tn>
class 类模版名
{

};

2.例子

1）单个参数

template<class T>
class CMath
{
public:
	CMath(T const& t1, T const& t2) :m_t1(t1), m_t2(t2) {}
	T add()//类内实现
	{
		return m_t1 + m_t2;
	}
    T add2();//类外实现
private:
	T m_t1;
	T m_t2;
};

//类外实现
template<class T>T CMath<T>::add()
{
   return m_t1 + m_t2;
}

2）多个参数

template<class A, class B>
class CMath
{
public:
       A m_a;
       B func(){};

};

3.实例化

template<class T>
class CMath
{
public:
	CMath(T const& t1, T const& t2) :m_t1(t1), m_t2(t2) {}
	T add()
	{
		return m_t1 + m_t2;
	}
private:
	T m_t1;
	T m_t2;
};

int main()
{
	int a = 10, b = 20;
	CMath<int> m(a, b);
	cout << m.add() << endl;

	return 0;
}

注意：

1）使用类模板必须对类模板进行实例化（产生真正的类），类模板本身并不代表一个确定的类型（不能用于定义对象），实例化之后才能具备类的语义（定义对象）；

2）类模板被实例化时类模板中的成员函数并没有实例化，成员函数只有在被调用时才会被实例化（即产生真正成员函数），成员虚函数除外；

3）某些类型虽然并没有提供类模板所需要的全部功能，但依旧可以实例化类模板，只要不调用那些未提供功能的成员函数即可。

4.类模板的静态成员

        类模板中的静态成员不是每个对象拥有一份，也不是类模板拥有一份，而是由类模板实例化的每一个真正的类各有一份，且为该实例化类定义的所有对象共享。

template<class T>
class A
{
public:
	static void print()
	{
		cout << "&m_i: "<< &m_i << endl<<"&m_t: "<< &m_t << endl;
	}

	static int m_i;
	static T m_t;
};
template<class T>int A<T>::m_i;
template<class T>T A<T>::m_t;

int main()
{
	A<int>x, y, z;
	x.print();
	y.print();
	z.print();
	A<int>::print();

	cout << "--------------------------" << endl;

	A<double>m,n,t;
	m.print();
	n.print();
	t.print();
	A<double>::print();

	return 0;
}

5.类模板的递归实例化

          由类模板实例化产生的类也可以用来实例化类模板自身，即类模板的递归实例化。

template<class T>
class Array
{
public:
	T& operator[](size_t i)//重载下标运算符
	{
		return m_arr[i];
	}
private:
	T m_arr[10];
};

int main()
{
	Array<Array<int>> m;
	for (size_t i = 0; i < 10; i++)
	{
		for (size_t j = 0; j < 10; j++)
		{
			m[i][j] = i + j;
		}
	}

	for (size_t i = 0; i < 10; i++)
	{
		for (size_t j = 0; j < 10; j++)
		{
			cout << m[i][j] << " ";
		}
		cout << endl;
	}

	return 0;
}