C+中的函数对象+；（C+；+；11） 我正在阅读 Boo:：函数< /> >，我对它的用法和它与文档中的其他C++构造或术语的关系感到困惑，例如： 在C++（C++ 11）的上下文中，代码> Boo:：函数< /> >，函数对象< /St>，符> /St>，以及 lambda表达式< /强>有什么区别？什么时候应该使用哪个结构？例如，我应该在什么时候将函数对象包装在boost:：function中，而不是直接使用该对象 以上所有C++都构造了不同的方法来实现函数语言中的什么叫做“强”闭包< /强>（一个函数，可能包含捕获变量，可以作为一个值传递，并被其他函数调用）？< /P> < P>函数对象和函子是相同的东西；实现函数调用操作符operator（）的对象。lambda表达式生成函数对象。具有某种特殊化类型的boost:：function/std:：function的对象也是函数对象

Lambda的特殊之处在于Lambda表达式具有匿名且唯一的类型，并且是一种方便的内联创建函子的方法

---

boost:：function

/

std:：function

的特殊之处在于，它将任何可调用实体转换为一个类型仅依赖于可调用实体签名的函子。例如，lambda表达式都有唯一的类型，因此很难在非泛型代码中传递它们。如果您从lambda创建一个

std:：function

，那么您可以很容易地传递包装好的lambda。

boost:：function和标准版本

std:：function

都是由li-brary提供的包装器。它们可能很昂贵，而且相当沉重，只有在您实际需要一组异构的、可调用的实体时，才应该使用它们。只要一次只需要一个可调用实体，使用

auto

或模板就更好了

下面是一个例子：

std::vector<std::function<int(int, int)>> v;

v.push_back(some_free_function);           // free function
v.push_back(&Foo::mem_fun, &x, _1, _2);    // member function bound to an object
v.push_back([&](int a, int b) -> int { return a + m[b]; });  // closure

int res = 0;
for (auto & f : v) { res += f(1, 2); }

---

转换是不必要的，模板化版本可以匹配实际（通常不可知）类型，例如绑定表达式或lambda表达式。

函数对象和函子通常以 概念。这意味着它们描述了一组类型的需求。A. 在C++11和新的 这个概念被称为

可调用
。可调用类型的对象
o
是
对象，其中表达式
o（ARGS）
为真。例子
对于
可调用的
是

int f() {return 23;}

struct FO {
  int operator()() const {return 23;}
};

通常会添加对
可调用的
的返回类型的一些要求
也您可以这样使用
可调用的
：

int apply(std::function<int(int,int)>)   // wasteful

template<typename Callable>
int call(Callable c) {
  return c();
}

call(&f);
call(FO());

int call(std::function<int()> c) {
  return c();
}

call(&f);
call(FO());

您需要记住，使用
std:：function
会对
性能，您应该仅在确定需要时使用它
信息技术在几乎所有其他情况下，模板都能解决您的问题。
因此
boost:：function
用于定义函数对象的签名？@Giorgio定义签名，但不定义其类型。@Giorgio不定义签名，而是隐藏签名以外的所有内容。它还方便地将非对象可调用实体作为对象处理。“例如，lambda表达式都有一个唯一的类型”：这是否意味着具有相同签名（例如，（int x，int y）->int）的两个lambda表达式有不同的类型？@Giorgio不仅如此，但是类型是唯一的，即使两个lambda表达式中的令牌的确切序列是相同的：
static_assert（！std:：is_same:：value，“这两个lambda表达式具有不同的类型！”）
int call(std::function<int()> c) {
  return c();
}

call(&f);
call(FO());