boost::forward_adapter предоставляет шаблон многоразового адаптера для объектов функций. Он передает RValues как ссылки на const, оставляя LValues as-is.

struct g // function object that only accept LValues
{
    template< typename T0, typename T1, typename T2 >
    void operator()(T0 & t0, T1 & t1, T2 & t2) const;
    typedef void result_type;
};
// Adapted version also accepts RValues and forwards
// them as references to const, LValues as-is
typedef boost::forward_adapter<g> f;

Другой адаптер, boost::lighweight_forward_adapter позволяет пересылать с некоторой помощью от пользователя, принимающего и раскручивающего обертки ссылки (см. Boost.Ref) для опорных аргументов, в отличие от всех других аргументов.

Функции-мишени должны быть совместимы с Boost.ResultOf, как и адаптеры.

Предположим, что у нас есть функция f, которую мы можем назвать так:

f(123,a_variable);

Теперь мы хотим написать еще одну общую функцию g, которую можно назвать так же, и возвращаем некоторый объект, который вызывает f с теми же аргументами.

f(123,a_variable) == g(f,123,a_variable).call_f()

Why would we want to do it, anyway?

Возможно, мы хотим запустить f несколько раз. Или, может быть, мы хотим запустить его в другой поток. Может быть, мы просто хотим инкапсулировать выражение вызова на данный момент, а затем использовать его с другим кодом, который позволяет составлять более сложные выражения, чтобы разложить его на шаблоны C++ и заставить компилятор генерировать некоторые механизмы, которые в конечном итоге вызывают f во время выполнения (другими словами; применить технику, которую обычно называют шаблонами экспрессии).

Now, how do we do it?

Плохая новость: это невозможно.

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

int y;
int const z = 0;

и

template< typename T > void func1(T & x);

мы можем позвонить

func1(y); // x is a reference to a non-const object
func1(z); // x is a reference to a const object

где

func1(1); // fails to compile.

Таким образом, мы можем безопасно хранить аргумент ссылки func1, и компилятор не позволяет нам хранить ссылку на объект с временным сроком службы.

Важно понимать, что непостоянство и связь объекта с эталонным параметром непостоянства являются двумя различными свойствами. Последнее является различием между LValues и RValues. Названия происходят от левой стороны и правой стороны выражений назначения, поэтому LValues обычно являются теми, которые вы можете назначить, и RValues временные результаты от выражения правой стороны.

y = 1+2;        // a is LValue, 1+2 is the expression producing the RValue,
// 1+2 = a;     // usually makes no sense. 
func1(y);       // works, because y is an LValue
// func1(1+2);  // fails to compile, because we only got an RValue.

Если мы добавим по параметру квалификацию const, наша функция также принимает значения RV:

template< typename T > void func2(T const & x);
// [...] function scope:
func2(1); // x is a reference to a const temporary, object,
func2(y); // x is a reference to a const object, while y is not const, and
func2(z); // x is a reference to a const object, just like z.

Во всех случаях аргумент x в func2 является конст-квалифицированной LValue. Мы можем использовать перегрузку функций для идентификации неконстовых значений:

template< typename T > void func3(T const & x); // #1
template< typename T > void func3(T & x);       // #2
// [...] function scope:
func3(1); // x is a reference to a const, temporary object in #1,
func3(y); // x is a reference to a non-const object in #2, and
func3(z); // x is a reference to a const object in #1.

Обратите внимание, что все аргументы x в перегруженной функции func3 являются LValues. На самом деле, в C++98 нет способа перенести RValues в функцию as-is. Также обратите внимание, что мы не можем отличить то, что раньше было квалифицированной LValue от RValue.

Это максимально близко к общей функции пересылки g, как описано выше с помощью C++. 98. См. The Forwarding Problem для очень подробного обсуждения, включая решения, требующие языковых изменений.

Теперь, для фактической реализации, нам нужны перегрузки 2N для N параметров (каждый с и без квалификатора const) для каждого числа аргументов (то есть 2^(Nmax+1) - 2^Nmin). Правильно, это означает, что сложность компиляции составляет O(2^N), но коэффициент низкий, поэтому он хорошо работает для разумного числа (<10) аргументов.

Поскольку эти утилиты учитываются из функционального модуля Boost.Fusion, я хочу поблагодарить Дэна Марсдена и Джоэла де Гусмана за то, что они позволили мне участвовать в разработке этой замечательной библиотеки.

Кроме того, я хочу отдать должное авторам приведенных ниже ссылок за их глубокое исследование проблемы и решения, реализованного здесь.

И последнее, но не менее важное: я хочу поблагодарить Весу Карновена и Пола Менсонидеса за библиотеку Boost Preprocessor. Без него у меня был бы внешний генератор кода для этого.