Функциональные объекты в C++ (C++11)

Функциональный объект и функтор — одно и то же; объект, реализующий оператор вызова функции operator(). Лямбда-выражение создает объект функции. Объекты с типом некоторой специализации boost::function/std::function также являются функциональными объектами.

Lambda отличается тем, что лямбда-выражения имеют анонимный и уникальный тип и являются удобным способом создания встроенного функтора.

boost::function/std::function отличается тем, что превращает любую вызываемую сущность в функтор, тип которого зависит только от сигнатуры вызываемой сущности. Например, каждое лямбда-выражение имеет уникальный тип, поэтому их трудно передать в неуниверсальном коде. Если вы создаете std::function из лямбды, вы можете легко передать обернутую лямбду.

И boost::function, и стандартная версия std::function являются оболочками, предоставляемыми библиотекой. Они потенциально дороги и довольно громоздки, и их следует использовать только в том случае, если вам действительно нужна коллекция разнородных вызываемых сущностей. Пока вам нужен только один вызываемый объект за раз, вам гораздо лучше использовать 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); }

Вот контрпример:

template <typename F>
int apply(F && f)
{
    return std::forward<F>(f)(1, 2);
}

В этом случае было бы совершенно бесполезно объявлять apply следующим образом:

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

Преобразование не требуется, и шаблонная версия может соответствовать фактическому (часто неизвестному) типу, например выражению связывания или лямбда-выражению.

Функциональные объекты и функторы часто описываются в терминах концепции. Это означает, что они описывают набор требований типа. Многое в отношении функторов изменилось в C++11, и новая концепция называется Callable. Объект o вызываемого типа — это объект, в котором (по существу) выражение o(ARGS) истинно. Примеры для Callable:

int f() {return 23;}

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

Часто также добавляются некоторые требования к возвращаемому типу Callable. Вы используете Callable следующим образом:

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

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

Конструкции, подобные приведенным выше, требуют, чтобы вы знали точный тип во время компиляции. Это не всегда возможно, и здесь на помощь приходит std::function.

std::function - это такой же Callable, но он позволяет вам стереть фактический тип, который вы вызываете (например, ваша функция, принимающая вызываемый объект, больше не является шаблоном). Тем не менее, вызов функции требует, чтобы вы знали ее аргументы и тип возвращаемого значения, поэтому они должны быть указаны как аргументы шаблона для std::function.

Вы бы использовали это так:

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

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

Вы должны помнить, что использование std::function может повлиять на производительность, и вы должны использовать его только тогда, когда уверены, что вам это нужно. Почти во всех других случаях шаблон решает вашу проблему.