函数包装器与模板

#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();
}