c++模板 --- 函数模板

c++模板 --- 函数模板 什么是模板?

把类型当做未知量来处理，写的函数或者类，不因为数据类型的改变，而要修改代码--->数据类型 改变，依然适用于代码（代码功能依旧可以使用）

 ps：求（int类型、string类型...）最大值

 因为数据类型的不同，需要多个相同的函数--->函数体是一样的，但是类型不同导致的额外代码

//求int类型的最大值
int Max(int a,int b)
{
    return a > b ? a : b;
}
//求string类型的最大值
string Max(string a,string b)
{
    return a > b ? a : b;
}

声明模板的语法

 引入模板，把类型当作未知量

//typename 可以换成class
template  
void print(T a)
{
	cout<

 存在单个未知类型 

//单个未知类型
template 	   //告诉编译器下面代码用到了一个未知类型_Ty,把_Ty当作类型去用
_Ty Max(_Ty a, _Ty b)      //_Ty 未知类型 a 未知参数    tip: _Ty 随便改,就是类型代号
{
	return a > b ? a : b;  //函数体一样
}

 对于函数来说可以存在唯一的未知类型，也可以存在多个未知类型

//可以多个未知类型
template     //用 , 作间隔
void print(_Ty1 one,_Ty2 two)              //如果还需要返回值可以_Ty3
{
	cout<("string1", "string2");
	print("string1", 1234);
}


string1
string2
string1
1234

调用函数模板

调用函数模板 ---> 常用的函数、函数体相同的函数，常用函数模板 ---> 一个函数写了多个函数的功能，不因为类型的改变，导致需要把函数重写

• 隐式调用 : 正常的函数传参即可调用--->不用管数据类型--->不需要显式传参

• 显示调用: 函数名<类型名>(参数)

 隐式调用

 直接调用

 遵守函数调用的规定，实参与形参类型一致

template 	   
_Ty Max(_Ty a, _Ty b)    
{
	return a > b ? a : b;  
}

int main(){
//隐式调用
	cout << Max(1, 2) << endl;
	cout << Max("string", "string1") << endl;
	cout << Max(1.1, 2.3) << endl;
}


2
string
2.3

显式调用

 显示调用: 函数名<类型名>(参数)

template 	   
_Ty Max(_Ty a, _Ty b)    
{
	return a > b ? a : b;  
}

int main(){
//显示调用    显式调用string类型参数
	cout << Max("abc", "abd") << endl;

}


abd



_Ty=string
a="abc"
b="abd"

函数模板的两种形态

• 普通函数当做函数模板(上面的代码已经证实)

• 类的成员函数是函数模板(用法和普通函数一样)

 类的成员函数是函数模板

class MM 
{
public:
	template     //成员函数
	void print(_Ty data) 
	{
		cout << data << endl;
	}

protected:
	string name;
	int age;
};
int main(){

//类中的成员函数是函数模板
	MM mm;                        //构造一个对象
	mm.print(123);                //隐式调用
	mm.print("ILoveyou"); //显式调用
	
}


123
ILoveyou

 类的成员函数的方式可以在类中声明在类外实现，在类外实现不能省略template这一块

class MM 
{
public:
	
	template 
	void printData(_Ty data);
protected:
	string name;
	int age;
};
//在类外实现不能省略template这一块
template 
void MM::printData(_Ty data) 
{
	cout << data << endl;
}
int main(){
    MM mm;
    mm.printData(12344);
}


12344

函数模板特殊的写法

• 缺省写法

• 存在常量类型  

模板函数可不可以缺省？        与函数传参一样，可以缺省处理

template 	//缺省写法
void printData(_Ty1 one, _Ty2 two)
{
	cout << one << "t" << two << endl;
}

void testFunc()
{
	printData("string", 1234);    //隐式调用无明显区别

//函数模板的缺省显式调用,可以不传类型,但参数不能少,第二个参数默认int类型,要传int类型的参数进去
    printData("ILoveyou", 12344);
}

int main()
{	

	testFunc();
	return 0;
}



string  1234
ILoveyou        12344

存在常量类型

//打印数组(不同类型的)函数,传长度的参数
template   //做缺省,可以隐式调用                  
void printArray(_Ty1 array)		      //_Ty1=int * 数组地址,size=3
{
	for (int i = 0; i < size; i++)    //声明1个变量size,意味着可以在函数里面使用这个变量
	{
		cout << array[i];
	}
	cout << endl;
}

void testFunc() 
{
	int testarray[3] = { 1,2,3 };
	//没有做缺省必须显示调用   参数类型
	printArray(testarray);

	//不能隐式调用,没有做缺省必须显式调用,做了缺省可以隐式调用
	printArray(testarray);

	
}

int main() {

	testFunc();
}



123
123