类模板总结

所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

函数模板定义形式

  由以下三部分组成：  模板说明 + 函数定义 + 函数模板调用

  template < 类型形式参数表 >

  类型  函数名 (形式参数表)

{

    //语句序列

}

1. 模板说明  

template    < 类型形式参数表 >  

类型形式参数的形式：

typename T1 ,  typename T2 , …… , typename Tn 

或 class T1 ,  class T2 , …… , class Tn

(注：typename 和 class 的效果完全等同)

2. 函数定义

 类型  函数名  (形式参数表)

{

}

注意：模板说明的类属参数必须在函数定义中出现一次

      函数参数表中可以使用类属类型参数，也可以使用一般类型参数

3. 函数模板调用

max<int>(a, b);  //显式类型调用

max(a, b);   //自动数据类型推导

函数模板和普通函数区别结论： 

两者允许并存

函数模板不允许自动类型转化

函数模板和普通函数在一起，调用规则：

1 函数模板可以像普通函数一样被重载

2 C++编译器优先考虑普通函数

3 如果函数模板可以产生一个更好的匹配，那么选择模板

4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

结论：

1. 编译器并不是把函数模板处理成能够处理任意类型的函数

2. 编译器从函数模板通过具体类型产生不同的函数

2.类模板定义

   类模板由模板说明和类说明构成

   模板说明同函数模板，如下：

         template    <类型形式参数表>

         类声明

例如：

   template  <typename Type>

class ClassName

{

//ClassName 的成员函数

   private ：

   Type DataMember;

}

1.父类一般类，子类是模板类, 和普通继承的玩法类似

2.子类是一般类，父类是模板类,继承时必须在子类里实例化父类的类型参数

3.父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中

总结：

在同一个cpp 文件中把模板类的成员函数放到类的外部，需要注意以下几点

1. 函数前声明 template    <类型形式参数表>
2. 类的成员函数前的类限定域说明必须要带上虚拟参数列表
3. 返回的变量是模板类的对象时必须带上虚拟参数列表
4. 成员函数参数中出现模板类的对象时必须带上虚拟参数列表
5. 成员函数内部没有限定

注意：当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离，因为类模板的特殊实现，我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件。

1. 类内部声明友元函数，必须写成一下形式

    template<typename T>

friend A<T> addA (A<T> &a, A<T> &b);

1. 友元函数实现 必须写成

template<typename T>

  A<T> add(A<T> &a, A<T> &b)

{

//......

}

1. 友元函数调用 必须写成

A<int> c4 = addA<int>(c1, c2);

总结：

• 从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员
•  和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化
• static 数据成员也可以使用虚拟类型参数T

6.类模板使用总结

归纳以上的介绍，可以这样声明和使用类模板：

1) 先写出一个实际的类。

2) 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的T)。

3) 在类声明前面加入一行，格式为：

    template <typename 虚拟类型参数>

如：

    template <typename numtype>

    class A

    {…}; //类体

4) 用类模板定义对象时用以下形式：

    类模板名<实际类型名> 对象名;

    或 类模板名<实际类型名> 对象名(实参表列);

如：

    A<int> cmp;

    A<int> cmp(3,7);

5) 如果在类模板外定义成员函数，应写成类模板形式：

   template <typename 虚拟类型参数>

   函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}

关于类模板的几点补充：

1) 类模板的类型参数可以有一个或多个，每个类型前面都必须加typename 或class，如：

    template <typename T1,typename T2>

    class someclass

    {…};

在定义对象时分别代入实际的类型名，如：

    someclass<int, char> object;

2) 和使用类一样，使用类模板时要注意其作用域，只有在它的有效作用域内用使用它定义对象。

3) 模板类也可以有支持继承，有层次关系，一个类模板可以作为基类，派生出派生模板类。

代码如下：

main.h

#include "Vector.cpp"
#include <iostream>
#include <Windows.h>


class Student
{
public:
	Student(const char* _name, int _age)
	{
		strcpy_s(name, 64, _name);
		age = _age;
	}

	~Student()
	{

	}

	Student()
	{
		age = 0;
		name[0] = NULL;
	}

	friend ostream& operator<<(ostream& os, const Student& object);

private:
	char name[64];
	int age;

};
int main(void)
{
	Vector<int> studentVector(10);

	for (int i = 0; i < studentVector.getLength(); i++)
	{
		studentVector[i] = i;
	}

	//依次序打印
	for (int i = 0; i < studentVector.getLength(); i++)
	{
		cout << studentVector[i] << endl;
	}

	//全部打印
	cout << studentVector << endl;



	//float类型
	Vector<float> studentVector1(10);

	for (int i = 0; i < studentVector1.getLength(); i++)
	{
		studentVector1[i] = i * 0.1f;
	}

	//依次序打印
	for (int i = 0; i < studentVector1.getLength(); i++)
	{
		cout << studentVector1[i] << endl;
	}

	//全部打印
	cout << studentVector1 << endl;

	Student s1("李小双", 28);
	Student s2("俩后", 40);

	Vector<Student> studentVector3(2);

	studentVector3[0] = s1;
	studentVector3[1] = s2;

	//依次序打印
	for (int i = 0; i < studentVector3.getLength(); i++)
	{
		cout << studentVector3[i] << endl;
	}

	//整体打印
	cout << studentVector3 << endl;

	system("pause");
	return 0;
}

ostream& operator<<(ostream& os, const Student& object)
{
	os << "姓名：" << object.name << "年龄：" << object.age << endl;

	return os;

}

Vector.h

#include <iostream>

using namespace std;

template <typename T>
class Vector
{
public:
	template <typename T>
	friend ostream& operator<< <T> (ostream& os, const Vector<T>& object);

public:
	Vector(int m_len=128);
	~Vector();
	
	Vector(const Vector& object);
	int getLength();
	T& operator[](int i);

	

	Vector& operator=(const Vector& object);


private:
	int m_len;
	T* m_size;

};

template <typename T>
ostream& operator<<(ostream& os, const Vector<T>& object);

Vector.cpp

#include "Vector.h"

template <typename T>
Vector<T>::Vector<T>(int size)
{
	this->m_len = size;
	//分配内存大小
	this->m_size = new T[m_len];
}

template <typename T>
Vector<T>::~Vector()
{
	if (m_size != NULL)
	{
		delete[] m_size;
		m_size = NULL;
		m_len = 0;
	}
}

template <typename T>
int Vector<T>::getLength()
{
	return m_len;
}

template <typename T>
ostream& operator<<(ostream& os, const Vector<T>& object)
{
	for (int i = 0; i < object.m_len; i++)
	{
		os << object.m_size[i] << endl;
	}

	return os;
}

template <typename T>
T& Vector<T>::operator[](int i)
{
	return m_size[i];
}

template <typename T>
Vector<T>::Vector<T>(const Vector<T>& object)
{
	if (m_size != NULL)
	{
		delete[] m_size;
		m_size = NULL;
		m_len = 0;
	}

	//分配内存
	this->m_len = object.m_len;
	this->m_size = new T[this->m_len];

	//赋值
	for (int i = 0; i < object.m_len; i++)
	{
		this->m_size[i] = object.m_size[i];
	}
}

//赋值构造函数
template <typename T>
Vector<T>& Vector<T>::operator=(const Vector<T>& object)
{
	if (this->m_size != NULL)
	{
		delete[] m_size;
		m_len = 0;
		m_size = NULL;
	}

	this->m_len = object.m_len;
	this->m_size = new T[this->m_len];

	for (int i = 0; i < object.m_len; i++)
	{
		this->m_size[i] = object.m_size[i];
	}

}