C++模板类的使用细节

#模板类的概念和定义
在需要定义功能相同参数类型不同的多个函数时，C++有函数模板很好的解决这一繁琐的操作，同样的当需要定义多个功能类似，而内部数据成员不同的类时，C++也提供了一种方法可以简化程序员所需要做的重复繁琐的操作，这就是类模板。

template <typename T> //定义好类型形式参数
class A {
public:
	//函数的参数列表使用虚拟类型
	A(T t = 0) {
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT() {
		return this->t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

如上述代码在类的函数参数列表，成员函数的返回值，成员变量处都可以使用虚拟类型代替。

#模板类对象的使用

// 当函数参数需要用到模板类参数的时候，需要在<>里显示指定类型
void printA(A<int> &a) {
	cout << a.getT() << endl;
}

//当模板类创建对象的时候，也需要在<>里显示指定类型
A<int> a(666);

总结：当需要用到模板类对象的地方都必要要显示指定类型

类模板的继承与被继承
直接上代码

// 一个普通类，A类
class A {
public:
	A(float a) {
		this->a = a;
	}

	float a;
};

//当父类是普通函数，子类是模板函数时，继承格式和普通函数的继承一样
template <typename B_b>
//模板类B类去继承普通类A类
class B : public A{
public:
	B(B_b b, float a) : A(a){
		this->b = b;
	}

	B_b b;
};

// 当父类是类模板时，子类是普通类时继承时应该显示指定类型
// C类是普通类去继承模板类B类
class C : public B<int>{
public:	
	C(char c, int b, float a) : B (b, a){
		this->c = c;
	}
	char c;
};

// 当父类和子类都是是类模板时，子类继承时也应该显示指定类型
// 模板类D类继承模板类 B类
template <typename D_d>
class D : public B<char>{
public:
	D(D_d d, char b, float a) : B (b, a){
		this->d = d;
	}

	D_d getD() {
		return d;
	}

	D_d d;
};

总结：从上面的代码可以看出，模板类其实是很呆的，在发生继承时如果要让模板类被继承，一定要显示指定出，模板类前定义好的虚拟类型到底是什么类型。

模板类的具体写法

// 先定义一个模板类的头文件
template <typename T>
class Template
{
public:
	Template();
	Template(T t);
	~Template();

	//声明函数时，当要使用模板类对象做返回值或者参数时，要记得写上定义好的虚拟类型
	Template<T> operator+(const Template<T>& temp);

	void print();

private:
	T t;
};


//下面是具体实现函数的cpp文件
#include "Template.h"
#include<iostream>

//实现模板类里的函数时首先在要函数前在声明好虚拟类型
template<typename T>
// 然后有返回值险先写返回值，之后在写上：类名<虚拟类型>::函数名(参数){具体实现}
Template<T>::Template::Template()
{
}

template <typename T>
Template<T>::Template(T t) {
	this->t = t;
}



template <typename T>
Template<T>::Template::~Template()
{
}

template<typename T>
Template<T> Template<T>::operator+(const Template<T>& temp)
{
	Template<T> ts;
	ts = this->t + temp.t;
	return ts;
}

template<typename T>
void Template<T>::print()
{
	std::cout << this->t<<std::endl;
}

总结：在实现模板类的成员函数时记得在有用到类名的地方，类名后面的<>中加上虚拟类型。还有要需要模板类对象的地方，一定要注意需不需要添加上类型声明。另外在使用模板类的成员函数时，头文件必须写后缀名为.cpp的文件，所以有了一个不成文的约定，在写模板函数的cpp文件时，把cpp文件重命名写做.hpp文件

模板类中的友元函数

//定义一个模板类
template<typename T>
class Test
{
public:
	Test();
	Test(T t);
	T getT();
	
	// 在模板类中声明一个友元函数
	// 因为友元函数归根结底时外部函数，不属于类本身，所以声明时也要加上template<typename T>来声明虚拟类型
	template<typename T>
	// 其他函数声明与普通模板类函数一致
	friend Test<T> add(Test<T> &t1, Test<T>& T2);
	
	//友元函数的实现
	template<typename T>
	Test<T> add(Test<T> &t1, Test<T>& t2) {
	// 大体上与普通模板类函数一样，只是因为归根结底是外部函数，在创建对象时，必须写上虚拟类型，而模板类内部的成员函数创建对象时可不写。
	Test<T> t3;
	t3 = t1.t + t2.t;
	return t3;
}

//友元函数的调用
Test<float> t4(4.3), t5(5.7);
Test<float> t6 = add<float>(t4, t5);
//必须在函数名和括号中间的<>中显示的写明类型

类模板中的静态成员
// 定义与普通类无异
static T TEMP;
// 初始化
// 老样子加上虚拟类型声明template <typename T>
template <typename T>
//格式也类似，数据类型 类名<虚拟类型>::静态变量名 = 0，数据类型也可以用虚拟类型代替
T Test<T>::TEMP = 0;

//注意事项
Test<int> t1;
Test<float> t2;
t1.TEMP = 100;
//虽然是同一个模板类，但是运行程序时候会发现，改变t1的静态变量时，t2并不会改变，
那是在实际传入参数的时候因为int和float是不同的类型，所以编译器根据不同的类型生成了
两版分别是int和float类型的类。所以t1和t2是不想通的。