C++模板

1、类模板的种类

类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。注意：是类的数据成员类型待定！！

单一待定类型； 多种待定类型 ；   多种待定类型（指定默认参数）

template<typename T>
class 类名
{
......
};
//template<class NameType, class AgeType>//指定两个待定参数类型
//template<class NameType, class AgeType = int> //指定默认参数

解释：
template声明创建模板，固定词语；
typename表明其后面的符号是一种数据类型，typename可以用class代替，等价
T是通用的数据类型，名称可以替换，通常为大写字母

注意：T可以是int ，float，string型等已有数据类型，也可以是自定义的类，或者结构体，或者其它类型。

2、类模板实例化对象

 没有指定类模板的待定参数类型时， 类模板实例化对象时，需指定全部的待定参数类型

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	void showPerson()
	{
		cout << "name: " << this->m_Name << "age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};


void test01()
{
	Person<string, int> p1("孙悟空", 999);//创建对象时，指定待定参数类型
    /* 模板类中  Person<string, int>可看做一个整体 此时person不能单独出现了，
    必然是Person<string, int>一起出现
    */
	p1.showPerson();
}
   
int main()
{
	test01();
	system("pause");
	return 0;
}

/* 模板类中  Person<string, int>可看做一个整体 此时person不能单独出现了，
    必然是Person<string, int>一起出现
    */

指定模板类的部分待定参数时，实例化对象须指定剩余的全部待定参数类型。

//指定默认参数时，实例化对象的两种操作
template<class NameType, class AgeType = int> //指定默认参数
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	void showPerson()
	{
		cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

Person p1("孙悟空", 1000);//错误的，类模板无法用自动类型推导
Person<string, int>p2("孙悟空", 1000);//正确，只能用显式指定类型推导
Person<string>p3("猪八戒", 999); //正确，类模板在参数列表中有默认参数

#include <iostream>
using namespace std;

//类模板中成员函数的创建时机
class Person1
{
public:
	void showPerson1()
	{
  		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>//T为待定数据类型
class Myclass
{
public:
	T obj;//T是待定类型，obj是实例化的对象   只有对象才能调用成员函数
	
	//类模板中的成员函数在调用的时候才创建，所以不会报错
	void func1()
	{
		obj.showPerson1();
	}

	void func2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	Myclass<Person1>m;//首先明白 Myclass<Person1>是类模板，Myclass是类名，m是对象；
	m.func1();//正确
    //func1()是类Myclass 中的函数，obj.showPerson1()是类T，即 类Person1中的函数
	//m.func2();//报错
    //无法调用 func2()中执行 obj.showPerson2()；但类Person1无showPerson2()函数
}

int main()
{
	test01();
	system("pause");
	return 0;
}

Myclass<Person1> m;

首先明白 Myclass<Person1> 是模板类，Myclass是类名，Person1是指定类型 ，m是对象；要看对象m的具体情况，回头看类的定义，并用给定类型 Person1  替换模板类 中的通用类型。

3、类模板对象做函数参数

学习目标：类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

指定传入的类型：直接显示对象的数据类型

       void printPerson1(Person<string, int>&p){  ...  }//即p对象中的数据类型完全指定

参数模板化：将对象中的参数变为模板进行传递

      参数模板化  指定类，不指定通用参数  
      template<class T1,class T2> //此时的函数也不是普通函数，而是模板函数
      void printPerson2(Person<T1,T2>&p)//传入函数的参数类型不唯一 ，可以理解为二维的
      {           ........                            }

整个类模板化：将这个对象类型模板化进行传递

template<class T> // 此时的函数，就只能是模板函数了
void printPerson3(T &p)
{    ...    }

//类模板对象做函数参数
template<class T1,class T2>
class Person
{
public:
	Person(T1 name,T2 age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}

	void showPerson()
	{
		cout << "name: " << this->m_Name << " age:" << this->m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

//1、指定传入类型 指定类，指定通用参数
void printPerson1(Person<string, int>&p)
{
	p.showPerson();//showPerson()函数是 类Person中的成员函数
}
void test01()
{
	Person<string, int>p("孙悟空", 199);//实例化对象并初始化对象
	printPerson1(p);//函数的传入参数 有初值才有意义，所以前一步要进行实例化对象并初始化对象
    //传入函数中的参数类型唯一
}

   
// 2、参数模板化  指定类，不指定通用参数
//此时的函数也不是普通函数，而是模板函数
template<class T1,class T2>
void printPerson2(Person<T1,T2>&p)//传入函数的参数类型不唯一 ，可以理解为二维的
{
	p.showPerson();
	cout << "T1的类型为:" << typeid(T1).name() << endl;
	cout << "T2的类型为:" << typeid(T2).name() << endl;
}
void test02()
{
	Person<string, int>p("猪八戒", 90);//函数调用前，还是要实例化和初始化
	printPerson2(p);
}

// 3、整个类模板化  不指定类，不指定通用参数
//此时的函数，就只能是模板函数了
template<class T>
void printPerson3(T &p)
{
	p.showPerson();
	cout << "T的类型为:" << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int>p("唐僧", 60);
	printPerson3(p);
}

int main()
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

4、类模板与继承

被继承的类，是一个模板类，此时的继承，具有一定的特殊性。

注意事项：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T（通用类型）的类型。否则编译器无法编译。

如果想灵活指定出父类中T的类型，子类也需为类模板！

普通类 继承 模板类

template<class T>
class Base
{
	T m;
};

//class Son: public Base //错误，必须要知道父类中的T类型，才能继承给子类
//class Son: public Base<T> //错误，必须要知道且指定父类中的T类型，才能继承给子类
class Son :public Base<int> //正确
{

};

void test01()
{
	Son s1;
}

模板类  继承  模板类

template<class T>
class Base
{
	T m;
};

template<class T1,class T2> //T1属于子类的，T2属于夫类的
class Son2 : public Base<T2>
{
public:
	Son2()
	{
		cout << "T1的类型为:" << typeid(T1).name() << endl;
		cout << "T2的类型为:" << typeid(T2).name() << endl;

	}
	T1 obj;
};

void test02()
{
	Son2<int,char> s2;//定义对象时指定子类个父类的通用类型
}

5、类模板成员函数的类外实现

类模板的成员函数类外实现时，需要加上模板 和模板参数列表

template<class T1,class T2>
class Person
{
 public:
   person(T1 name,T2 age);
 
   void showPerson();
   
 T1 m_Name;
 T2 m_Age;

}
//构造函数的类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)//person<T1,T2>:: 告诉这是一个类模板里面的函数
{
 this->m_name=name;
 this->m_Age=age;
}
//成员函数的类外实现
template<class T1,class T2>
void Person<T1,T2>::showPerson()
{
 cout<<"姓名:"<<this->name<<"年龄:"<<this->m_Age<<endl;
}

6、类模板分文件编写

 解决方式1：

 比如person.h中写类的生命，person.cpp中写类的定义。

在main.c的文件中调用这个类的时候，包含的头文件不能是#include “person.h”，而应该是#include “person.cpp”

person.h

person.cpp

 需要用到这个类的时候，要包含的是源文件，即.cpp文件

7、函数模板的注意事项

自动类型推导，必须推导出一致的数据类型T才可以使用。

template<class T>
void Swap(T&a,T&b)
{T temp=a;a=b;b=temp}

void test01()
{
 int a=10;int b=20;char c='C';
Swap(a,b);//正确 
Swap(a,c);//错误，函数定义时，传入两参数类型都是T，但调用时，两传入参数不一样

}

模板必须确定出T的范围，才可以使用