template模板详解第二集

软件	操作系统	标准
visual stdio Code	win11	C++11

获取代码资源点击这里或加Q群：928357277一起学习，博主期待你们的到来

使用头文件: #include <iostream>
G++编译方式： g++ -std=c++11 .\main.cpp //在终端用C++11标准编译

学习目录

模板用法1：默认参数及其推导

//函数模板带默认参数仅不支持C++98的模板特性，C++11之后的函数模板也不需要遵循从右往左的指定规则
//如template<typename T = int,typename X>也被视为正确
template<typename T ,typename X = char>
void defaultParameter( T a = 0 ,X x =0) //模板函数带默认参数
{
    std::cout<<"a = "<<a <<std::endl;
    std::cout<<"x = "<<x <<std::endl;
}
void printDefaultParameter() //推导过程
{
    //defaultParameter(); 错误推导
    defaultParameter(4);//打印 4,0
    defaultParameter(5,'l');//打印 5,'1'
}

int main()
{
	printDefaultParameter();//执行
	reuturn 1;
}

模板用法2：外部模板的声明及其实例化

提示：外部模板的声明在过程上同普通外部变量声明除了语法上的差别，基本一致

/*
普通变量声明
extern int a;
ina a = 10;//实例化
*/

template<typename T>
void extrenFun(T a){std::cout<<"a = "<<a <<std::endl;}

extern template void extrenFun<int>(int); //外部声明
template void extrenFun<int>(int); //使用外部模板必须进行显式实例化，这点和普通外部变量一样

int main()
{
	extrenFun(55); //调用 打印 a = 55;
	return 1;
}

模板用法3：匿名类型的声明不能用于模板实参位置

struct myStruct{} mys; //mystruct：类型 、mys：类型变量
struct {int a;} mys2;//匿名类型变量
typedef struct { int a;} myStruct2;//匿名类型
//定义一个模板类
template<typename T>class structCap{};
template<typename T> struct mytemplate{};
//定义一个模板函数
template<typename T>void toMy( T t){}

int main()
{
    struct myStruct3{} mys3; //定义一个局部类型变量mys3
    structCap<myStruct> a;//支持C++98
    structCap<myStruct2> b; //该语法只支持C++11及以上版本
    structCap<myStruct3> c; //该语法只支持C++11及以上版本
    // mytemplate< struct {int a;} > x;  匿名类型声明不允许出现在实参位置
    toMy(mys2); toMy(a); toMy(mys3);//该语法只支持C++11及以上版本，否则报错
    return 1;
    
}

模板用法4：模板作为返回值的非显式推导

template<typename Return,typename T1,typename T2>
inline Return max(const T1&t1,const T2& t2) 
{
    return t1>t2?t1:t2; //条件运算符返回最大值，注意，返回值，参数皆是模板
}
int main()
{
	//调用时只指定了返回值的类型为float
    float a = max<float>(2,3.1);//显示指定返回列表，隐式参数自动推导
    std::cout<<" a = " <<a <<std::endl;//打印 a = 3.1
 	return  1；
}

模板用法5：重载函数模板

阅读提示：下面对voerloadMax()函数重载了三次，主函数进了不同参数的调用和打印说明


//voerloadMax()模板函数被重载了三次，第二次和第三次为模板类型的重载

int const& overloadMax(int const& a,int const & b) //求俩个整数的大小
{
    std::cout<<" 1"<<std::endl;
    return a>b?a:b;
}
template<typename T>
const T&  overloadMax(const T&a,const T& b)//求俩个任意类型的变量大小
{
    std::cout<<" 2"<<std::endl;
    return a>b?a:b; 
}
template<typename T> 
T const& overloadMax(const T&a,const T& b,T const& c) //求是哪个任意类型的变量大小
{
    std::cout<<" 3"<<std::endl;
    return overloadMax(overloadMax(a,b),c);
}
//接下来我们调用各种函数观察
int main()
{
    overloadMax(2,4); //调用 1
    overloadMax('a',3.6); //调用 1 说明不同类型的参数只能使用非模板函数
    overloadMax(2,3.5); //调用 1
    overloadMax(3.4,5.6,6.6); //调用 3,2,2
    overloadMax<double>(3,4,5);
    //打印结果 1,1,1,3,2,2,3,2,2 
 	return  1；
}

模板用法6：任意数量模板(可变长参数模板)

可变长参数模板定义形式：template<typename… T>
参数的定义：T… t;
参数包的调用形式：fun(…t);
也可进行实参的实例化：fun() 、fun<double,int>，也就是对推导类型做了变长扩展
具体细节看下面代码


template<typename... T>//实参实例化
struct thisAny{ void fun(){std::cout<<"~~~~~~"<<std::endl;}};

template <typename T,typename U>
void print(T a,T b,U c) //利用模板默认参数的推导功能解析包的三个传入变量
{
    std::cout<<a<<std::endl;
    std::cout<<b<<std::endl;
    std::cout<<c<<std::endl;
}

template<typename... Args>//函数实参调佣
void functionAny(Args... args)
{
    print(args...);
}
//函数实现
int mian()
{
    //实参实例化 template<typename... T> tihsAny{};第一行定义
    thisAny<> type1; //只指明是模板类型的实例化
    thisAny<int> type2; //只指明是int一种类型的实例化
    thisAny<int ,double>type3; //指明是int,double两个类型的实例化
    //实参调用
    functionAny(1,2,"hello");
    //打印出 1,2,"hello"
 	return  1；
}