C++11函数包装器

原创已于 2025-03-16 18:25:00 修改 · 982 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2025-03-16 18:20:58 首次发布

C++基础语法专栏收录该内容

7 篇文章

订阅专栏

std::function

function是C++11引入的类，可以用任何可调用对象作为参数，构造出一个新对象。

可调用对象有函数指针，仿函数，lambda等

下面是function的声明

可以看到是一个类模板，第一个参数是函数返回值类型，第二个是可变参数模板，表示函数的参数列表

先看一个例子

#include<iostream>
//使用function需要包含头文件
#include<functional>
int main()
{
	std::function<int(int, int)> add = [](int a, int b)->int
    {
	    return a + b; 
    };
    std::cout << add(1, 2) << std::endl;
	return 0;
}

这是对lambda表达式的包装，关于lambda表达式，详见 C++11 lambda表达式-优快云博客

function可以将一系列参数列表和返回值相同的函数用相同的类型接收，这在某些情况下提供了极大的便利。

比如对表达式求值，要根据符号是+、-、*、/中的某一个进行运算，一种选择是使用条件分支语句，也就是if或者switch case语句，但是写起来有些繁琐，这时可以使用function

#include <map>
#include <functional>
int main()
{
	std::map<char, std::function<int(int, int)>> op
	{
		{'+', [](int x, int y)->int {return x + y; }},
		{'-', [](int x, int y)->int {return x - y; }},
		{'*', [](int x, int y)->int {return x * y; }},
		{'/', [](int x, int y)->int {return x / y; }}
	};
	std::cout << op['+'](10, 20) << std::endl;
	return 0;
}

使用function就可以省去大量的条件判断，并且map可以随时扩展，增加新的功能。

注意事项

包装静态成员函数

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)> f1 = &Plus::plusi;
	return 0;
}

包装非静态成员函数

第一种方法

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	Plus p;
	std::function<double(Plus*, double, double)> f1 = &Plus::plusd;
	std::cout << f1(&p, 1.1, 2.2) << std::endl;
	return 0;
}

由于非静态的成员函数会有一个this指针，于是在包装时需要加上这个指针参数，在调用时要显式加上这个参数

还有一种写法

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<double(Plus, double, double)> f1 = &Plus::plusd;
	std::cout << f1(Plus(), 1.1, 2.2) << std::endl;
	return 0;
}

这种写法与第一种的区别在于，不传入Plus*，而是传入Plus，可能你不禁会想，为什么传入Plus也可以，这里解释一种理解方式：

function接收函数指针实例化后是一个类，这个类有operator()方法，这个方法接收了参数，在我举的例子中，参数是Plus(), 1.1, 1.2，内部不是直接显式地把这几个参数传入回调函数，而是使用类似p.plusd(1.1,1.2)或者p->plus(1.1, 1.2)进行成员函数调用。所以这里可以选择不传指针。

而且，this指针不支持显式传递，所以底层当然不是直接显式传参。

std::bind

用法

bind是一个函数模板

// 原型如下：
#include <functional>
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);

bind以某个可调用对象为参数，生成一个新的可调用对象，fn是可调用对象。

直接看下面的例子

int sub(int a, int b)
{
	return a - b;
}		
int main()
{
	auto sub1 = std::bind(sub, 1, std::placeholders::_1);
	std::cout << sub1(2) << std::endl;
	return 0;
}

sub是传入的可调用对象，1传给sub的第一个形参也就是a，std::placeholders是一个命名空间，里面有从_1,_2,...,_n很多个数字，表示第一个实参，第二个实参，...，第n个实参。

在这里表示传入的实参2

bind返回了一个可调用对象，这个可调用对象的第一个参数a被固定成了a，第二个参数是sub1传入的第一个参数，经过bind作用后，你可以理解为sub1是下面的函数

int sub1(int b)
{
	return 1 - b;
}

再看一个复杂点的例子

int sub(int a, int b, int c)
{
	return a - b - c;
}
int main()
{
	auto sub1 = std::bind(sub, 1, std::placeholders::_2, std::placeholders::_1);
	std::cout << sub1(2, 3) << std::endl;
	return 0;
}

a被定为了1，b是传入的第二个实参，c是传入的第一个实参

相当于

int sub1(int b, int c)
{
	return 1 - c - b;
}

当然也可以

int sub(int a, int b, int c)
{
	return a - b - c;
}
int main()
{
	auto sub1 = std::bind(sub, std::placeholders::_2, 2, std::placeholders::_1);
	std::cout << sub1(2, 3) << std::endl;
	return 0;
}

这时sub1相当于

int sub1(int a, int c)
{
	return c - 2 - a;
}

理解了bind的用法后，来看看它的应用场景

应用场景

在使用function包装非静态成员函数时，需要多传一个参数，以上面function举的例子来看

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<double(Plus, double, double)> f1 = &Plus::plusd;
	std::cout << f1(Plus(), 1.1, 2.2) << std::endl;
	return 0;
}

需要加一个Plus()，这时就可以使用bind

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
using namespace std::placeholders;
int main()
{
	std::function<double(double, double)> f1 = std::bind(&Plus::plusd, Plus(), _1, _2);
	std::cout << f1(1.1, 2.2) << std::endl;
	return 0;
}

现在使用f1就不用再传Plus()了。

而且，如果有一个函数，有绑定某个参数为某些值得需求时，bind也能派上用场