类模板与函数模板包装器

 函数包装器：

 

/* 函数包装器 */

#include<iostream>

using namespace std;

// T 代表任何数据 F代表任何操作(可以是函数，函数模板的一个实例化) 
template <typename T,typename F>
T run(T t,F f)
{
    return f(t);
}

int add(int num)
{
    return num+10;
}

template <typename T> 
T add(T t)
{
    return t+10;
}



void main()
{
    cout << run(100,add) << endl;
    
    cout << run(10.9,add<double>) << endl;

    cin.get();
}

类包装器：

 

/* 类包装器 */

#include<iostream>

using namespace std;

// T 代表任何数据 
// F代表任何操作(可以是函数，函数模板的一个实例化，类的成员函数) 
// F如果是类的成员函数
// 类包装器可以处理类模板 ，处理类
template <typename T,typename F>// run就是类包装器
T run(T t,F f)
{
    
    return f(t);
}

class Fun
{
public:
    int num;
    Fun(int x):num(x)
    {
        
    }
    
    // ()可以把对象名当作函数使用
    int operator ()(int data)// 类的成员函数
    {
        cout << "operator" << endl;
        return data-num;
    }

};




void main()
{
    Fun fun1(20);

//    cout << fun1(40) << endl;

    cout << run(100,fun1) << endl;

    cin.get();
}

//-------------------------------------------------------------------

template<typename T>
class FunT
{
public:
    T t;
    FunT(T x)::t(x)
    {
        
    }
    
    T operator ()(T data)
    {
        cout << "operator T" << endl;
        return data-t;
    }

};




void main()
{
    FunT<double> funt(10.8);

    cout << funt(20.8) << endl;// 10

    cout << run(108.9,funt) << endl;
    

    cin.get();
}

//-------------------------------------------------------------------

/* 非基本数据类型 */


#include<iostream>

using namespace std;

// T 代表任何数据 
// F代表任何操作(可以是函数，函数模板的一个实例化，类的成员函数) 
// F如果是类的成员函数
// 类包装器可以处理类模板 ，处理类
template <typename T,typename F>// run就是类包装器
T run(T t,F f)
{
    
    return f(t);
}

// 类包装器必须一致 T可以是数据类型 指针类型

// typeid(num1).name RTTI 实时类型检测  获取数据类型; 
// decltype(num1) num2; 自动获取对象的数据类型进行拷贝 创建
// template 可以用自动推理的数据类型decltype
//     类包装器必须一致 T 可以是数据类型  指针类型
// 如果是数据 都是数据  如果是指针都是指针
// 包装器接口，是固话流程让数据与操作的流程固话，数据与操作都不固话
// 百度的搜索  每次搜索创建一个线程  T t是搜索的数据 F f 是搜索的算法
// 重载() 可以吧对象当作函数来使用


template<typename T,int n>
class auto_point
{
public:
    auto_point()
    {
        cout << typeid(T).name << "auto_point构造" << endl;
        p = new T[n];// 分配内存
    }

    ~auto_point()
    {
        cout << typeid(T).name << "auto_point销毁" << endl;
    }
public:
    T *p;
};


template<typename F>
class freeall
{
public:
    freeall()
    {
        cout << typeid(F).name << "freeall构造" << endl;
    }

    F *operator ()(F *p)// 释放内存
    {
        cout << typeid(F).name << "freeall销毁" << endl;
        delete []p;
        return nullptr;
    }

};



void main()
{

    auto num1 = 1.3;
    cout << typeid(num1).name << endl;
    decltype(num1) num2;
    cout << typeid(num2).name << endl;


    cin.get();
}


//-------------------------------------------------------------------


void main()
{
    auto_point<decltype(10.9),10> p;// 模板的参数可以是自动推理

    //int *p = new int[10];
    //delete []p;// 自动推理数据类型

    cin.get();
}

//-------------------------------------------------------------------

class myclass
{
public:
    myclass()
    {
        cout << "myclass构造" << endl;
    }

    ~myclass()
    {
        cout << "myclass销毁" << endl;
    }
};

void main()
{
    myclass my1;
    auto_point<decltype(my1),3> auto1;// 根据自动推理实现调用模板
    

    freeall<decltype(my1)> freeX;// 自动推理实现模板构建
    run(auto1.p,freeX);


    cin.get();
}