C++模板初阶

C++中的另一种编程思想成为 泛型编程（编写与类型无关的通用代码，是代码复用的一种手段），主要利用的技术就是模板。
C++中提供两种模板机制： 函数模板和 类模板

1.函数模板

1.1函数模板的概念

函数模板代表了一个函数家族，**该函数模板与类型无关，在使用时被参数化，**根据实参类型产生函数的特定类型版本。

1.2函数模板的格式

template<typename T1,typename T2,typename T3...>

返回值类型 函数名（参数列表）{}
typename是用来定义模板参数的关键字，也可以用class

1.3函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐实例化和显式实例化。

1.3.1隐式类型实例化

让编译器根据实参推演模板参数的实际类型

void MySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}
void test01()
{
	int a = 10;
	int b = 20;
    char c='c';
    MySwap(a, b);//必须要推导出一致的数据类型T才能使
    MySwap(a, c);//错误 a为int类型 c为char类型 模板参数列表中只有一个T
    //无法推导出T为int类型还是char类型 
    //解决方法：1.用户自己来强制转化 2.使用显式类型实例化
    MySwap(a,<int>c);
 }

需要注意的是隐式类型实例化必须要推导出一致的数据类型T才能使用！

1.3.2显式类型实例化

在函数名后的<>中指定模板参数的实际类型

void MySwap(T &a, T &b)
{

	T temp = a;
	a = b;
	b = temp;
}
void test01()
{
    int a = 10;
	char c = 'c';
    MySwap<int>(a, c);//显式实例化 
}

1.4普通函数和函数模板的区别

1.普通函数调用时可以发生自动类型转换（隐式类型转换）
2.函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3.如果利用显示指定类型的方式，可以发生隐式类型转换

1.5普通函数和模板函数的调用规则

①如果普通函数和函数模板都可以实现，优先调用普通函数

#include<iostream>
using namespace std;
void Myprint(int a,int b)
{
    cout << "调用普通函数" << endl;
}
template<class T>
void Myprint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
void test()
{
    int a = 10;
    int b = 20;
    Myprint(a, b);
}
int main()
{
    test();
    return 0;
}

②可以通过空模板参数列表来强制调用函数模板

void test()
{
    int a = 10;
    int b = 20;
    Myprint<>(a, b)//通过空模板参数列表来强制调用函数模板
}

③函数模板也可以发生重载

void Myprint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
template<class T>
void Myprint(T a, T b,T c)//重载参数列表不同
{
    cout << "调用重载的函数模板" << endl;
}

④如果函数模板可以产生更好的匹配，有限调用函数模板

void test()
{
    char a='a';
    char b='b';
    Myprint(a, b);
}

2.类模板

2.1.类模板的声明和定义

template<class T1，class T2，class T3...>
class //类模板名
{
//类内成员定义
}

#include<iostream>
#include<string>
using namespace std;
template<class Nametype,class Agetype>
class Person
{
public:
	Person(Nametype name, Agetype age)
	{
		m_name = name;
		m_age = age;
	}
	void showperson()
	{
		cout << "Name:" << m_name <<" "<< "Age:"<< m_age << endl;

	}
	Nametype m_name;
	Agetype m_age;
};
void test01()
{
	Person<string, int> p1("小明", 14);
	p1.showperson();

}
int main()
{
	test01();
	return 0;

}

2.2类模板和函数模板的区别

①类模板没有自动类型推导的使用方式

#include<iostream>
#include<string>
using namespace std;
template<class Nametype,class Agetype>
class Person
{
public:
	Person(Nametype name, Agetype age)
	{
		m_name = name;
		m_age = age;
	}
	void showperson()
	{
		cout << "Name:" << m_name <<" "<< "Age:"<< m_age << endl;

	}
	Nametype m_name;
	Agetype m_age;
};
//1.类模板没有自动类型推导的使用方式
void test01()
{
	//Person p1("小明", 14);错误 类模板不能自动类型推导 只能用显式指定类型
	Person<string, int> p1("小明", 14);//显式指定类型
	p1.showperson();

}

②类模板在模板的参数列表中可以有默认参数

#include<iostream>
#include<string>
using namespace std;
template<class Nametype,class Agetype=int>
//类模板在模板的参数列表中可以有默认参数 默认Age为int类型
class Person
{
public:
	Person(Nametype name, Agetype age)
	{
		m_name = name;
		m_age = age;
	}
	void showperson()
	{
		cout << "Name:" << m_name <<" "<< "Age:"<< m_age << endl;

	}
	Nametype m_name;
	Agetype m_age;
};
void test02()
{
	Person<string> p2("李晨", 18);//前面模板的参数列表中定义了Age的类型

}

2.3类模板成员函数的类外实现

类模板中函数放在类外进行定义时，需要加模板参数列表。类模板名字不是真正的类，而实例化的结果才是真正的类

#include<iostream>
#include<string>
using namespace std;
template<class Nametype,class Agetype>
class Person
{
Public:
    Person(Nametype name, Agetype age);
    void showperson();
    Nametype m_name;
	Agetype m_age;
};
template<class Nametype,class Agetype>//在类外进行定义时，需要加模板参数列表
Person<Nametype,Agetype>::Person(Nametype name, Agetype age);
{
        m_name = name;
		m_age = age;
}
template<class Nametype,class Agetype>//在类外进行定义时，需要加模板参数列表
void Person<Nametype,Agetype>:: showperson()
{
    cout << "Name:" << m_name <<" "<< "Age:"<< m_age << endl;
}