C++——函数模板

1.模板的概念

模板就是建立通用的模具,大大提高复用性

2.函数模板

 *c++另一种编程思想为泛型编程,主要利用的技术是模板
 *c++提供两种模板机制:函数模板和类模板

函数模板语法

1.函数模板作用:

    建立一个通用函数,其返回值类型和形参类型可以不具体定制,用一个虚拟的类型来代表.

    语法:template<typename T>
    函数声明或定义

    解释:
    templat -- 声明创建模板
    typename --  表面其后面的符号是一种数据类型,可以用class代替
    T -- 通用的数据类型,名称可以替换,通常为大写字母

//两个整形交换函数
void swapInt(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

//交换俩个浮点型函数
void swapDouble(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

//函数模板
template<typename T> //声明一个模板,告诉编译器后面代码中紧跟着的T不要报错,T是一个通用数据类型
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;

	//swapInt(a, b);
	//利用函数模板交换
	//两种方式使用函数模板
	//1.自动类型推导
	//mySwap(a, b);//传入函数体的时候,编译器自动推导出类型

	//2.显示指定类型
	mySwap<int>(a, b);//<>指的是模板参数列表,告诉编译器模板的T是int类型

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	
	double c = 1.1;
	double d = 2.2;
	
	//swapInt(c, d);
	//cout << "c=" << c << endl;
	//cout << "d=" << d << endl;
}

2.函数模版注意事项

 注意事项:
    * 自动类型推导,必须推导出一致的数据类型T,才可以使用
    * 模版必须要确定出T的数据类型,才可以使用
    

template<class T>//typename可以替换成class
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

//1.自动类型推导,必须推导出一致的数据类型T才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//mySwap(a, b);//正确!
	//mySwap(a, c);//错误!推导不出一致的数据的T类型
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

//2.模版必须确定出T的数据类型,才可以使用
template<class T>
void func()
{
	cout << "func 调用" << endl;
}

void test02()
{
  func<int>();//即便func没有用到T,想调用func就得给T一个数据类型,让编译器指定T是什么数据类型才能正常调用
}

    3.普通函数与函数模版的区别

普通函数与函数模版区别:
     * 普通函数调用时可以发生自动类型转换(隐式类型转换)
     * 函数模版调用时,如果利用自动类型推导,不会发生隐式类型转换
     * 如果利用显示指定类型的方式,可以发生隐式类型转换

//普通函数与函数模版的区别

//1.普通函数调用可以发生隐式类型转换
//2.函数模版 用自动类型推导,不可以发生隐式类型转换
//3.函数模版 用显示指定类型,可以发生隐式类型转换

//普通函数
int myAdd01(int a , int b)
{
	return a + b;
}

//函数模版
template<class T>
T myAdd02(T a, T b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	int b = 20;
	int c = 'c';//a-97 c-99

	cout << myAdd01(a, c) << endl;//c被隐式的转成了a类型

	//自动类型推导 不会发生隐式类型转换
	//cout << myAdd02(a, c) << endl;//新的版本不会报错,编译器会帮你进行转换,但是老版本会报错


	//显示指定类型  会发生隐式类型转换
	cout << myAdd02<int>(a, c) << endl;

}

     4.普通函数与函数模版的调用规则

调用规则如下:
        1.如果函数模版和普通函数都可以实现,优先调用普通函数(函数名一样,优先调普通函数)
        2.可以通过空模版参数列表来强调函数模版(空模版:myPrint<>(a, b);<>;里面什么都不写)
        3.函数模版可以发生重载
        4,如果函数模版可以产生更好的匹配,优先调用模版
    总结:既然提供了函数模版,最好就不要提供普通函数,否则容易出现二义性

    5.模版的局限性

 局限性:
      *模版的通用不是万能的
       例如传入的是俩个数组,数组不能直接赋值,那么a=b就无法实现了
       再例如 传入的是像Person这样的自定义数据类型,也无法正常运行
       因此c++为了解决这种问题提供模版的重载可以为这些特点的类型提供具体的模版
  总结:
     *利用具体化的模版,可以解决自定义类型的通用化
     * 学习模版并不是为了写模版,而是在STL能够运用系统提供的模版

#include<iostream>
using namespace std;
#include<string>

//模版的局限性
//模版并不是万能的,有些特定数据类型,需要用具体化方式做特殊实现

class Person
{
	public:
		Person(string name, int age)
		{
			this->m_Name = name;
			this->m_Age = age;
		}

	//姓名
	string m_Name;
	//年龄
	int m_Age;

};


//对比两个数据是否相等函数 
template<class T>
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//利用具体化Person的版本实现代码,具体化优先调用
template<>bool myCompare(Person& p1, Person& p2)//template<>,告诉编译器这是用模版重载的版本
{
	if (p2.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a=!b" << endl;
	}
}

void test02()
{
//没报错是因为还没运行没调用,编译器还不知道,一运行,编译器发现T是Person自定义类型就傻了-报错
	Person p1("Tom", 10);
	Person p2("Tom", 10);

	bool ret = myCompare(p1, p2);
	if(ret) 
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
}

int main()
{
	//test01();
	test02();

	system("pause");

	return 0;
}

仅个人看视频笔记与理解,如有误可指出谢谢