Boost之高阶函数——函数对象

最新推荐文章于 2021-06-06 00:29:02 发布

delphiwcdj

最新推荐文章于 2021-06-06 00:29:02 发布

阅读量2k

点赞数

分类专栏： Boost

本文链接：https://blog.csdn.net/delphiwcdj/article/details/9564659

版权

Boost 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

2013-07-28 wcdj

函数对象，可能称为'高阶函数'更为适合。它实际上是指那些可以被传入到其它函数或是从其它函数返回的一类函数。在C++中高阶函数是被实现为函数对象的，所以这个标题还是有意义的，本文总结几个用于处理函数对象的 Boost C++ 库。

1 Boost.Bind

Boost.Bind 是这样的一个库，它简化了由C++标准中的 std::bind1st() 和std::bind2nd() 模板函数所提供的一个机制：将这些函数与几乎不限数量的参数一起使用，就可以得到指定签名的函数。这种情形的一个最好的例子就是在C++标准中定义的多个不同算法。

#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <boost/bind.hpp>

void print(int i) 
{ 
  std::cout << i << std::endl; 
} 

void add(int i, int j) 
{ 
  std::cout << i + j << std::endl; 
} 

bool compare(int i, int j) 
{ 
  return i > j; 
} 

void print_vec(std::vector<int> &v)
{
	std::vector<int>::iterator iter;
	for (iter = v.begin(); iter != v.end(); ++iter)
	{
		print(*iter);
	}
}

int main() 
{ 
  std::vector<int> v; 
  v.push_back(1); 
  v.push_back(3); 
  v.push_back(2); 

  // ok
  std::for_each(v.begin(), v.end(), print); 
  std::cout << "--------------" << std::endl;

  // error, 由于 std::for_each() 要求的是仅接受一个参数的函数，所以不能直接传入 add() 函数
  //std::for_each(v.begin(), v.end(), add); 

  // Boost.Bind 简化了不同函数之间的绑定。 它只包含一个 boost::bind() 模板函数，定义于 boost/bind.hpp 中
  // 【注释1】
  std::for_each(v.begin(), v.end(), boost::bind(add, 10, _1)); 
  std::cout << "--------------" << std::endl;

  // ok, std::sort() 算法要求一个二元函数作为其第三个参数
  std::sort(v.begin(), v.end(), compare);
  print_vec(v);
  std::cout << "--------------" << std::endl;
  
  // ok, 由于 compare() 本身就是一个二元函数，所以使用 boost::bind() 确是多余的
  // 【注释2】
  std::sort(v.begin(), v.end(), boost::bind(compare, _1, _2));
  print_vec(v);
  std::cout << "--------------" << std::endl;

  // 不过使用 boost::bind() 还是有意义的。例如，如果容器要按升序排列而又不能修改 compare() 函数的定义
  // 【注释3】
  std::sort(v.begin(), v.end(), boost::bind(compare, _2, _1));
  print_vec(v);

  return 0;
} 
/*
mba:bind gerryyang$ ./bind 
1
3
2
--------------
11
13
12
--------------
3
2
1
--------------
3
2
1
--------------
1
2
3
 
* */

【注释1】

像 add() 这样的函数不再需要为了要用于 std::for_each() 而转换为函数对象。使用boost::bind()，这个函数可以忽略其第一个参数而使用。

因为 add() 函数要求两个参数，两个参数都必须传递给 boost::bind()。第一个参数是常数值10，而第二个参数则是一个怪异的 _1。

_1 被称为占位符(placeholder)，定义于 Boost.Bind。除了 _1，Boost.Bind 还定义了_2 和_3。通过使用这些占位符，boost::bind() 可以变为一元、二元或三元的函数。对于_1,boost::bind() 变成了一个一元函数 - 即只要求一个参数的函数。这是必需的，因为std::for_each() 正是要求一个一元函数作为其第三个参数。

当这个程序执行时，std::for_each() 对容器 v 中的第一个元素调用该一元函数。元素的值通过占位符_1 传入到一元函数中。这个占位符和常数值被进一步传递到add() 函数。通过使用这种机制，std::for_each() 只看到了由boost::bind() 所定义的一元函数。而boost::bind() 本身则只是调用了另一个函数，并将常数值或占位符作为参数传入给它。

【注释2】

因为使用了两个占位符 _1 和 _2，所以 boost::bind() 定义了一个二元函数。std::sort() 算法以容器v 的两个元素来调用该函数，并根据返回值来对容器进行排序。基于compare() 函数的定义，容器将被按降序排列。

【注释3】

仅改变了占位符的顺序：_2 被作为第一参数传递，而 _1 则被作为第二参数传递至 compare()，这样即可改变排序的顺序。

2 Boost.Ref

Boost.Ref 通常与 Boost.Bind 一起使用。它提供了两个函数 -boost::ref() 和boost::cref() - 定义于boost/ref.hpp。当要用于boost::bind() 的函数带有至少一个引用参数时，Boost.Ref 就很重要了。由于boost::bind() 会复制它的参数，所以引用必须特别处理。

#include <boost/bind.hpp> 
#include <iostream> 
#include <vector> 
#include <algorithm> 

void add(int i, int j, std::ostream &os) 
{ 
  os << i + j << std::endl; 
} 

int main() 
{ 
  std::vector<int> v; 
  v.push_back(1); 
  v.push_back(3); 
  v.push_back(2); 

  // 【注释1】
  std::for_each(v.begin(), v.end(), boost::bind(add, 10, _1, boost::ref(std::cout))); 

  return 0;
} 
/*
mba:bind gerryyang$ ./bind_ref 
11
13
12
 * */

【注释1】

以上例子使用了上一节中的 add() 函数。不过这一次该函数需要一个流对象的引用来打印信息。因为传给boost::bind() 的参数是以值方式传递的，所以std::cout 不能直接使用，否则该函数会试图创建它的一份拷贝。通过使用模板函数boost::ref()，像std::cout 这样的流就可以被以引用方式传递，也就可以成功编译上面这个例子了。要以引用方式传递常量对象，可以使用模板函数boost::cref()。

3 Boost.Function

为了封装函数指针，Boost.Function 提供了一个名为boost::function 的类。它定义于boost/function.hpp。boost::function 可以定义一个指针，指向具有特定签名的函数。

#include <boost/function.hpp> 
#include <iostream> 
#include <cstdlib> 
#include <cstring> 

struct world 
{ 
	void hello(std::ostream &os) 
	{ 
		os << "Hello, world!" << std::endl; 
	} 
}; 

int main() 
{ 
	// 【注释1】
	boost::function<int (const char*)> f1 = std::atoi; 
	std::cout << f1("1609") << std::endl; 

	f1 = std::strlen; 
	std::cout << f1("1609") << std::endl; 

	// 【注释2】
	try 
	{ 
		boost::function<int (const char*)> f2; 
		f2(""); 
	} 
	catch (boost::bad_function_call &ex) 
	{ 
		std::cout << ex.what() << std::endl; 
	} 

	boost::function<int (const char*)> f3; 
	if (f3.empty())
	{
		std::cout << "f3 is empty object, should not use" << std::endl;
	}

	// 【注释3】
	boost::function<void (world*, std::ostream&)> f4 = &world::hello; 
	world w; 
	f4(&w, boost::ref(std::cout)); 

	return 0;
} 
/*
mba:bind gerryyang$ ./function 
1609
4
call to empty boost::function
f3 is empty object, should not use
Hello, world!
* */

【注释1】

定义了一个指针 f1，它可以指向某个接受一个类型为 const char* 的参数且返回一个类型为int 的值的函数。定义完成后，匹配此签名的函数均可赋值给这个指针。这个例程就是先将std::atoi() 赋值给f1，然后再将它重赋值为std::strlen()。注意，给定的数据类型并不需要精确匹配：虽然std::strlen() 是以std::size_t 作为返回类型的，但是它也可以被赋值给f1。因为f 1是一个函数指针，所以被赋值的函数可以通过重载的operator()操作符来调用。取决于当前被赋值的是哪一个函数，在以上例子中将调用std::atoi() 或std::strlen()。

【注释2】

如果 f 2未赋予一个函数而被调用，则会抛出一个 boost::bad_function_call 异常。注意，将值 0 赋给一个boost::function 类型的函数指针，将会释放当前所赋的函数。释放之后再调用它也会导致boost::bad_function_call 异常被抛出。要检查一个函数指针是否被赋值某个函数，可以使用empty() 函数或 operator bool() 操作符。

【注释3】

通过使用 Boost.Function，类成员函数也可以被赋值给类型为 boost::function 的对象。在调用这样的一个函数时，传入的第一个参数表示了该函数被调用的那个特定对象。因此，在模板定义中的左括号后的第一个参数必须是该特定类的指针。接下来的参数才是表示相应的成员函数的签名。这个程序还使用了来自 Boost.Ref 库的boost::ref()，它提供了一个方便的机制向 Boost.Function 传递引用。

4 Boost.Lambda

匿名函数 - 又称为 lambda 函数 - 已经在多种编程语言中存在，但 C++ 除外。不过在 Boost.Lambda 库的帮助下，现在在 C++ 应用中也可以使用它们了。lambda 函数的目标是令源代码更为紧凑，从而也更容易理解。

#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <boost/lambda/lambda.hpp> 
#include <boost/lambda/if.hpp> 

void print(int i) 
{ 
	std::cout << i << std::endl; 
} 

int main() 
{ 
	std::vector<int> v; 
	v.push_back(1); 
	v.push_back(3); 
	v.push_back(2); 

	// 【注释1】
	std::for_each(v.begin(), v.end(), print); 
	std::cout << "--------------" << std::endl;
	
	// 【注释2】
	std::for_each(v.begin(), v.end(), std::cout << boost::lambda::_1 << "\n"); 
	std::cout << "--------------" << std::endl;

	// 只将大于1的元素写出到标准输出流
	// 【注释3】
	std::for_each(v.begin(), v.end(), 
			boost::lambda::if_then(boost::lambda::_1 > 1, 
				std::cout << boost::lambda::_1 << "\n")); 

	return 0;
} 
/*
mba:bind gerryyang$ ./lambda 
1
3
2
--------------
1
3
2
--------------
3
2 
* */

【注释1】

接受容器 v 中的元素并使用 print() 函数将它们写出到标准输出流。由于print() 只是写出一个简单的int，所以该函数的实现相当简单。严格来说，它是如此地简单，以致于如果可以在std::for_each() 算法里面直接定义它的话，会更为方便；从而省去增加一个函数的需要。另外一个好处是代码更为紧凑，使得算法与负责数据输出的函数不是局部性分离的。 Boost.Lambda 正好使之成为现实。

【注释2】

Boost.Lambda 提供了几个结构来定义匿名函数。代码就被置于执行的地方，从而省去将它包装为一个函数再进行相应的函数调用的这些开销。与原来的例子一样，这个程序将容器v 的所有元素写出至标准输出流。

与 Boost.Bind 相类似，Boost.Lambda 也定义了三个占位符，名为 _1, _2 和 _3。但与 Boost.Bind 不同的是，这些占位符是定义在单独的名字空间的。因此，该例中的第一个占位符是通过 boost::lambda::_1 来引用的。为了满足编译器的要求，必须包含相应的头文件boost/lambda/lambda.hpp。

虽然代码的位置位于 std::for_each() 的第三个参数处，看起来很怪异，但 Boost.Lambda 可以写出正常的 C++ 代码。通过使用占位符，容器v 的元素可以通过<< 传给std::cout 以将它们写出到标准输出流。

虽然 Boost.Lambda 非常强大，但也有一些缺点。要在以上例子中插入换行的话，必须用 "\n" 来替代 std::endl 才能成功编译。因为一元std::endl 模板函数所要求的类型不同于 lambda 函数std::cout << boost::lambda::_1 的函数，所以在此不能使用它。

下一个版本的 C++ 标准很可能会将 lambda 函数作为 C++ 语言本身的组成部分加入，从而消除对单独的库的需要。但是在下一个版本到来并被不同的编译器厂商所采用可能还需要好几年。在此之前，Boost.Lambda 被证明是一个完美的替代品。

【注释3】

头文件 boost/lambda/if.hpp 定义了几个结构，允许在 lambda 函数内部使用if 语句。最基本的结构是boost::lambda::if_then() 模板函数，它要求两个参数：第一个参数对条件求值 - 如果为真，则执行第二个参数。如例中所示，每个参数本身都可以是 lambda 函数。

除了 boost::lambda::if_then(), Boost.Lambda 还提供了 boost::lambda::if_then_else() 和 boost::lambda::if_then_else_return() 模板函数 - 它们都要求三个参数。另外还提供了用于实现循环、转型操作符，甚至是throw - 允许 lambda 函数抛出异常 - 的模板函数。

虽然可以用这些模板函数在 C++ 中构造出复杂的 lambda 函数，但是你必须要考虑其它方面，如可读性和可维护性。因为别人需要学习并理解额外的函数，如用boost::lambda::if_then() 来替代已知的 C++ 关键字if 和else，lambda 函数的好处通常随着它的复杂性而降低。多数情况下，更为合理的方法是用熟悉的 C++ 结构定义一个单独的函数。

5 总结

Boost.Bind 可替换来自C++标准的著名的std::bind1st() 和std::bind2nd() 函数，而Boost.Function 则提供了一个用于封装函数指针的类。最后，Boost.Lambda 则引入了一种创建匿名函数的方法。

6 参考

[1] http://blog.csdn.net/delphiwcdj/article/details/6201017

[2] http://zh.highscore.de/cpp/boost/

delphiwcdj

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Boost之高阶函数——函数对象

20130728 wcdj函数对象，可能称为'高阶函数'更为适合。它实际上是指那些可以被传入到其它函数或是从其它函数返回的一类函数。在C++中高阶函数是被实现为函数对象的，所以这个标题还是有意义的，本文总结几个用于处理函数对象的 Boost C++ 库。1 Boost.BindBoost.Bind 是这样的一个库，它简化了由C++标准中的 std::bind1st(
复制链接

扫一扫

专栏目录