【C++】仿函数、lambda表达式、包装器

﹏ヽ暗。殇╰゛Y 2024-03-26 14:28 75阅读 0赞

### 1.仿函数 ###

仿函数是什么？仿函数就是类中的成员函数，这个成员函数可以让对象模仿函数调用的行为。

*  函数调用的行为：函数名(函数参数)
 *  C++中可以让类实现：函数名(函数参数)调用函数

自己写一个仿函数：

*  重载()运算符

class Sum
    {
    public:
    	int operator()(int a, int b)
    	{
    		return a + b;
    	}
    };

#### **1.1 operator()的调用方式** ####

成员函数operator()由三种调用方式：

函数重载的显示调用、重载的隐式调用、类名()仿函数调用。

int main()
    {
    	Sum object;
    	cout << object.operator()(1, 3) << endl; // 重载函数的显示调用
    	cout << object(1, 4) << endl; // 重载的隐式调用
    	cout << Sum()(1, 5) << endl;// 类名() 这种形态的调用叫仿函数
    	return 0;
    }

--------------------

**接触比较多的仿函数是两个排序准则：greater<>()，less<>()。**

--------------------

#### 1.2 greater<>()和less<>()的使用 ####

C++中有sort函数，实现在algorithm中，库中的sort函数默认是升序的；

可以先看一下sort的原型：

template <class _RanIt>
    _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last) { // order [_First, _Last)
        _STD sort(_First, _Last, less<>{});
    }

**sort的最后一个参数，传递的是一个仿函数，默认是less<>()。**

void Print(vector<int> v)
    {
    	for (auto e : v)
    	{
    		cout << e << " ";
    	}
    	cout << endl;
    }
    int main()
    {
    	vector<int> v{ 8, 1, 5, 0, 9 };
    	sort(v.begin(), v.end());
    	Print(v);
    	return 0;
    }

![d5f1a69e2d0ac2bb00c397f72d3ff5d2.png][]

打印函数Print需要多次使用，多以进行封装。

如果不使用默认的less<>()，使用greater<>()，是不是就是降序排列？

int main()
    {
    	vector<int> v{ 8, 1, 5, 0, 9 };
    	sort(v.begin(), v.end(), greater<int>());
    	Print(v);
    	return 0;
    }

![9bdbd1757f99b33af2eeb1a049cb2aa6.png][]

那知道了仿函数的原理，我们也可以自己手写一个仿函数：

template <class T>
    class Compare
    {
    public:
    	bool operator()(T a, T b)
    	{
    		return a < b;// 左边小，右边大，为升序
    	}
    };
    int main()
    {
    	vector<int> v{ 8, 1, 5, 0, 9 };
    	sort(v.begin(), v.end(), Compare<int>());
    	Print(v);
    	return 0;
    }

![bc786f0ee8c373088c8f27177a83c9d5.png][]

### 2.lambda表达式 ###

#### 2.1 基本语法 ####

lambda表达式书写格式： **\[捕捉列表\] (参数) -> 返回值\{ statement \}**

*  **返回值一般都不写，编译器会自动推导**

我们先来写一个简单的lambda：

// 交换的lambda
    int main()
    {
    	int x = 0, y = 1;
    	auto swap = [](int& x, int& y) {int tmp = x; x = y; y = tmp; };
    	swap(x, y);
    	cout << x << " " << y << endl;
    	return 0;
    }

![7a398646ab961fdbc67c1cc2fc9cfd8c.png][]

这里我们并没有使用到捕捉列表，其实使用捕捉列表会更加简单：

int main()
    {
    	int x = 0, y = 1;
    	auto swap = [&x, &y]{int tmp = x; x = y; y = tmp; };
    	swap();
    	cout << x << " " << y << endl;
    	return 0;
    }

#### 2.2 lambda表达式与仿函数 ####

观察下面一段程序：

struct Goods
    {
    	string _name; // 名字
    	double _price; // 价格
    	int _evaluate; // 评价
    	Goods(const char* str, double price, int evaluate)
    		:_name(str)
    		, _price(price)
    		, _evaluate(evaluate)
    	{}
    };
    struct ComparePriceLess
    {
    	bool operator()(const Goods& gl, const Goods& gr)
    	{
    		return gl._price < gr._price;
    	}
    };
    struct ComparePriceGreater
    {
    	bool operator()(const Goods& gl, const Goods& gr)
    	{
    		return gl._price > gr._price;
    	}
    };
    int main()
    {
    	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
       3 }, { "菠萝", 1.5, 4 } };
    	sort(v.begin(), v.end(), ComparePriceLess());
    	sort(v.begin(), v.end(), ComparePriceGreater());
    }

按照商品的名字、价格、评价排序，而且可以从小到大排，也可以从大到小排，所以有六种排序方式；如果给sort传递仿函数，那么需要我们写六个类，重载operator()。

使用lambda表达式的话就很容易解决：

int main()
    {
    	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
       3 }, { "菠萝", 1.5, 4 } };
    	// 按名字排序
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._name < g2._name; });
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._name > g2._name; });
    	//按价格排序
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._price < g2._price; });
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._price > g2._price; });
    	// 按评价排序
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._evaluate < g2._evaluate; });
    	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._evaluate > g2._evaluate; });
    }

### 3.包装器 ###

#### 3.1 function ####

C++中的function本质是一个类模板，也是一个包装器。

那么我们来看看，我们为什么需要function呢？

ret = func(x);
    // 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
    是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
    为什么呢？我们继续往下看
    template<class F, class T>
    T useF(F f, T x)
    {
        static int count = 0;
        cout << "count:" << ++count << endl;
        cout << "count:" << &count << endl;
        return f(x);
    }
    double f(double i)
    {
    	return i / 2;
    }
    struct Functor
    {
    	double operator()(double d)
        {
        return d / 3;
        }
    };
    int main()
    {
        // 函数名
        cout << useF(f, 11.11) << endl;
        // 函数对象
        cout << useF(Functor(), 11.11) << endl;
        // lamber表达式
        cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;
        return 0;
    }

![29e9f8917330b058a28f8a371d12a61e.png][]

count的地址不同，说明**useF函数模板实例化了三份，效率降低。**

**使用包装器解决上面的问题。**

--------------------

std::function在头文件<functional>
    // 类模板原型如下
    template <class T> function;     // undefined
    template <class Ret, class... Args>
    class function<Ret(Args...)>;
    模板参数说明：
    Ret: 被调用函数的返回类型
    Args…：被调用函数的形参

#include <functional>
    int f(int a, int b)
    {
    	return a + b;
    }
    struct Functor
    {
    public:
    	int operator() (int a, int b)
    	{
    		return a + b;
    	}
    };
    class Plus
    {
    public:
    	static int plusi(int a, int b)
    	{
    		return a + b;
    	}
    	double plusd(double a, double b)
    	{
    		return a + b;
    	}
    };
    int main()
    {
    	// 函数名(函数指针)
    	std::function<int(int, int)> func1 = f;
    	cout << func1(1, 2) << endl;
    	// 函数对象
    	std::function<int(int, int)> func2 = Functor();
    	cout << func2(1, 2) << endl;
    	// lamber表达式
    	std::function<int(int, int)> func3 = [](const int a, const int b)
    	{return a + b; };
    	cout << func3(1, 2) << endl;
    
    	// 类的成员函数
    	std::function<int(int, int)> func4 = Plus::plusi;
    	cout << func4(1, 2) << endl;
    	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
    	cout << func5(Plus(), 1.1, 2.2) << endl;//非静态成员函数的指针需要类对象调用Plus()是一个匿名对象
    	return 0;
    }

下面看useF使用包装器后的效果：

template<class F, class T>
    T useF(F f, T x)
    {
        static int count = 0;
        cout << "count:" << ++count << endl;
        cout << "count:" << &count << endl;
        return f(x);
    }
    double f(double i)
    {
        return i / 2;
    }
    struct Functor
    {
        double operator()(double d)
        {
            return d / 3;
        }
    };
    int main()
    {
        std::function<double(double)> f1 = f;
        cout << useF(f1, 11.11) << endl;
        std::function<double(double)> f2 = Functor();
        cout << useF(f2, 11.11) << endl;
        std::function<double(double)> f3 = [](double d)->double { return d / 4; };
        cout << useF(f3, 11.11) << endl;
        return 0;
    }

![1f5c1e28a7339cd9ea3dd645d1359788.png][]

观察可以看出，**使用包装器后useF只实例化出了一份。**

--------------------

#### 3.2 bind ####

std::bind函数定义在头文件中，**是一个函数模板，它就像一个函数包装器**，**接受一个可调用对象,生成一个新的可调用对象来“适应”原对象的参数列表**。一般而 言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

函数原型：

template <class Fn, class... Args>
    /* unspecified */ bind (Fn&& fn, Args&&... args);
    // with return type (2) 
    template <class Ret, class Fn, class... Args>
    /* unspecified */ bind (Fn&& fn, Args&&... args);

arg\_list中的参数可能包含形如\_n的名字，其中n是一个整数，这些参数是“占位符”，表示

newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对

象中参数的位置：\_1为newCallable的第一个参数，\_2为第二个参数，以此类推。

**下面举一个例子来更好的理解bind：**

void print(int a, int b, int c)
    {
    	cout << a << " " << b << " " << c << endl;
    }
    int main()
    {
    	auto foo1 = std::bind(print, 1, 2, 3);
    	foo1();
    	auto foo2 = std::bind(print,1, std::placeholders::_1, std::placeholders::_2);// _1和_2是有顺序的
    	foo2(1, 3);// 1 1 3
    	foo2(3, 1);// 1 3 1
    	return 0;
    }

![d3ae6e48c919eb447f2d13a4315dd1c9.png][]

[d5f1a69e2d0ac2bb00c397f72d3ff5d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d2bb3efab2ad4ceb83f2d168777b61e7.png
[9bdbd1757f99b33af2eeb1a049cb2aa6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b6e75e4fe07c4c3994d601629fdf959f.png
[bc786f0ee8c373088c8f27177a83c9d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4893161853d44bf6b3246e2864edf168.png
[7a398646ab961fdbc67c1cc2fc9cfd8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/599cd6da98324ca6b715da82bef12569.png
[29e9f8917330b058a28f8a371d12a61e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/618958a1ed674f54ba498bf040798522.png
[1f5c1e28a7339cd9ea3dd645d1359788.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/82dc6daf87d949209a10ac76a76ccffd.png
[d3ae6e48c919eb447f2d13a4315dd1c9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2be04e06f30c4b54ac7cca2b24f0ea4c.png