函数包装器与模板
#include<functional> //函数包装器
using std::function;
int add(int a, int b)
{
return a + b;
}
template<class T,class F>
T run(T t1,T t2,F f)
{
return f(t1,t2);
}
void main()
{
function<int(int, int)>fun1 = add; //包装函数
function<int(int, int)>fun2 = [](int a, int b)->int {return a - b;};
cout<< run(10, 19, fun1)<<endl; //默认推导 原生优先
cout << run< int, function<int(int, int)> >(10, 19, fun1) << endl;
cin.get();
}
函数模板的嵌套
#include<vector>
#include<list>
template<class T1,class T2>
void showall(vector<T1>v,list<T2>l)
{
vector< vector<T1>v >v1; //二维数组
for (auto i : v)
{
cout << i << endl;
}
for (auto i : l)
{
cout << i << endl;
}
}
void main()
{
vector<int> myint{ 1,2,3,4,5 };
vector<char>mych{ 'A','B','C' };
list<int> myint1{ 1,2,3,4,5 };
list<char>mych1{ 'A','B','C' };
showall(myint, mych1);
cin.get();
}
模板与引用
//变量 左值引用 右值引用 原则不能冲突
//ref 变量 -> 左值引用
//move 左值引用 右值引用
//模板自带引用的话 无论& ,&&都是原本
//T t , ref都是原本 否则是副本
template<class T>
void print1(T t) //ref
{
cout << " void print(T t) " << endl;
t += 1;
cout << t << endl;
}
template<class T>
void print2(T&t)
{
cout << " void print(T&t) " << endl;
t += 1;
cout << t << endl;
}
template<class T>
void print3(T&&t) //move
{
cout << " void print(T&&t) " << endl;
t += 1;
cout << t << endl;
}
template<class T>
void printint(T&&t) //move
{
cout << " void print(T&&t) " << endl;
t += 1;
cout << t << endl;
}
void main()
{
int data (100);
int &rdata(data);
int &&rrdata(data+1);
//print1(data); //副本
//print1(ref(data)); //原本 引用包装 包装变量或者引用
//print1(rdata); //副本
//print1(ref(rdata)); //原本
//print1(rrdata); //右值 引用 内存保存的临时值 副本
//print1(ref(rrdata));//原本
//print2(data); //模板自带引用的情况下 都是原本
//print2(rdata);
//print2(rrdata);
print3(data); //模板自带引用的情况下 都是原本
print3(rdata);
print3(rrdata);
cout << "data:" << data << endl;
cout << "rdata:" << rdata << endl;
cout << "rrdata:" << rrdata << endl;
int num = 10;
int&rnum(num);
printint(move(num)); //移动语义 数据 左值引用转换为右值引用
printint(move(rnum));
cin.get();
}
模板的重载
//函数重载： 参数个数 类型 顺序
//与返回值无关
//有指针优先匹配指针
template<class T>
void go(T t1)
{
cout <<"TTTTTTTTTTTTTTTTTT"<< endl;
cout << t1 << endl;
}
template<class T>
void go(T* t1)
{
cout << "***************"<< endl;
cout << *t1 << endl;
}
void main()
{
int*p = new int[5]{ 1,2,3,4,5 };
go(p[0]);
go(p);
go(&p); //地址趋向地址
cin.get();
}
模板的类型默认参数和函数参数默认函数
//保证所有的类型参数可以推导 默认 明确
//函数参数遵循函数默认值规则
template <class T=int,int n=10> //模板参数可以有默认值
void bobo(T t)
{
cout << n << endl;
cout << bobo << endl;
}
//节约输入参数 类型参数 可以指定或者不指定 任意 填充从左向右 必须覆盖类型参数
template<class T1=int,class T2=int,class T3=int,class T4=int>
//函数参数 默认统一在右边 至少要把不默认的填充了才能调用
void boda(T1 t1,T2 t2=5.7,T3 t3=6.66,T4 t4=9.99)
{
cout << t1<<" "<<t2<< " " << t3<< " " << t4<< endl;
}
void mainr9()
{
bobo<>(50.50); //自动推理
bobo<int,250>(50.50);
boda<int,int,int,int>(10); //类型必须明确才能执行
cin.get();
}
函数模板的指针匹配
//模板自动匹配*多的
template<class T>
void com(T*p)
{
cout << "*: " ;
cout << typeid(p).name() << end;
}
template<class T>
void com(T**p)
{
cout << "**: ";
cout << typeid(p).name() << end;
}
void main()
{
int *p(nullptr);
int **pp(nullptr);
int ***ppp(nullptr);
com(p);
com(pp);
com(ppp);
cin.get();
}
