函数包装器，函数私有类处理

1、函数包装器

#include<iostream>

#include<functional>

 

//函数包装器

//第一，设计执行接口,接口设计关卡（），计数

//第二，函数包装器依赖于函数模板，实现通用泛型

//第三，函数代码可以内嵌在另外一个函数，实现函数怀孕

//函数包装器，用于管理内嵌函数，外部函数调用

 

//函数包装器， T数据类型， F是函数

template<typename T, typename F>

T run(T v, F f)

{

    static int count = 0;

    count++;//计数器

    std::cout << "run  一个参数的包装器 执行" << count << "次" << std::endl;

    if (count > 1)

    {

        T  vx(0);

        return  vx;

    }

    return f(v);//函数传入参数

}

 

template<typename T, typename F>

T run(T v1, T v2, F f)

{

    return f(v1, v2);//函数传入参数

}

 

int  cheng(int a, int b)

{

    return a*b;

}

 

void main()

{

    using  std::cout;  //C++11. namespace,专门引用一个关键字，不需要std

    using  std::endl;

    using  std::function;

    //using namespace std;

    using  std::cin;

 

    double db = 12.9;//double *2

    int  num1 = 19;

    int  num2 = 29;

 

    //第一个double是返回值类型，第二个参数类型是参数类型

    function<double(double)> fun1 = [](double u)

    {

        return u * 2;

    };

    function<double(double)> fun2 = [](double u)

    {

        return u*u;

    };

    function<int(int, int)> fun3 = [](int u1, int u2)

    {

        return u1 + u2;

    };

    function<int(int, int)> fun4 = cheng; //fun4函数指针

 

    cout << run(db, fun1) << endl;//调用

    cout << run(db, fun2) << endl;//调用

    cout << run(num1, num2, fun3) << endl;//调用

    cout << run(num1, num2, fun4) << endl;//调用

    cin.get();//等价于你输入一字符getchar;

}

运行结果：

2.处理类的私有

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<string>

 

//函数模板实现通用，可以根据自有数据类型，进行优化

 

//结构体可以直接赋值（没有私有变量）

 

//所有成员都是公有的类型可以赋值（一开始初始化）

//如果类有私有成员变量，不可以用{}初始化

 

//类的对象之间默认是可以直接赋值

 

//类，结构体都有一个默认赋值操作= 浅拷贝 ，交换数据

 

//深拷贝用的最多，函数模板的覆盖

class info

{

public:

    char name[40];

    char *p;

    int data;

private:

    int num;

public:

    void set(int X)

    {

        this->num = X;//通过接口设置私有变量

    }

    int get()

    {

        return this->num;//返回值，副本机制

    }

};

 

template<typename T>

void swap(T &a, T &b)

{

    std::cout << "通用函数模板" << std::endl;

    T temp = a;

    a = b;

    b = temp;//交换两个变量

}

 

//模板为空，明确类型，

template<>

void  swap(info &info1, info &info2)

{

    std::cout << "特有函数模板" << std::endl;

    //通用模板可以实现通用，针对自己的数据类型做出优化

    //计数器，对象交换计数器

    info temp = info1;

    info1 = info2;

    info2 = temp;

}

 

void main()

{

    info info1;

    info info2;

    std::strcpy(info1.name, "yincheng");

    std::strcpy(info2.name, "chengyin ");

    info1.data = 102;

    info2.data = 201;//初始化

    info1.p = new char[10];

    std::strcpy(info1.p, "魔王");

 

    //info2.p = nullptr;//C++的空指针

    info2.p = new char[100];

    std::strcpy(info2.p, "da魔王");

    info1.set(89);

    info2.set(98);

 

    swap(info1, info2);

 

    std::cout << info1.name << "   " << info1.data << "   " << info1.get() << std::endl;

    std::cout << info1.p << std::endl;

    std::cout << info2.name << "   " << info2.data << "    " << info2.get() << std::endl;

    std::cout << info2.p << std::endl;

    std::cin.get();

}

运行截图