std :: function как пользовательский потоковый манипулятор

Я пытаюсь использовать возможности C ++ 11, чтобы упростить создание пользовательских потоковых манипуляторов. Я могу использовать лямбда-функции в качестве манипуляторов, но не std::function<ostream&(ostream&)>,

Вот код, сводится к следующему:

#include <iostream>
#include <functional>
using namespace std;

auto lambdaManip = [] (ostream& stream) -> ostream& {
stream << "Hello world" << endl;
};
function<ostream& (ostream&)> functionManip = [] (ostream& stream) -> ostream& {
stream << "Hello world" << endl;
};

int main (int argc, char** argv) {
cout << lambdaManip;    // OK
cout << functionManip;  // Compiler error
}

Второй cout Сбой заявления со следующим:

g++-4 src/Solve.cpp -c -g -std=c++0x -o src/Solve.o -I/home/ekrohne/minisat
src/Solve.cpp: In function 'int main(int, char**)':
src/Solve.cpp:24:11: error: cannot bind 'std::ostream' lvalue to 'std::basic_ostream<char>&&'
/usr/lib/gcc/i686-pc-cygwin/4.5.3/include/c++/ostream:579:5: error:   initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char, _Traits = std::char_traits<char>, _Tp = std::function<std::basic_ostream<char>&(std::basic_ostream<char>&)>]'

Почему это не удается? Я использую Cygwin GCC 4.5.3.

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

auto getAdditionFunctor();

auto getAdditionFunctor() {
return [] (int x, int y) { return x + y };
};

…но явно не работает. Есть ли альтернативный синтаксис, который работает? Я не могу себе представить, что это может быть, поэтому я могу застрять std::function,

Если бы у меня было решение второго вопроса, то первый вопрос был бы спорным.

Спасибо.

определяющий operator<<(ostream&, std::function<ostream&(ostream&)> помог. Я неправильно прочитал веб-страницу, и у меня сложилось впечатление, что ostream был достаточно умен, чтобы рассматривать произвольный объект, который имел operator() как манипулятор. Я был неправ по этому поводу. Кроме того, простой lambda Я построил, вероятно, только что был скомпилирован в простой старой функции, как мне сказали. Действительно, если я использую захват переменной, чтобы гарантировать, что lambda не простая функция, то компилятор не работает. Также объекты с operator() определенные (по умолчанию) не рассматриваются как манипуляторы:

class Manipulator {
ostream& operator()(ostream& stream) const {
return stream << "Hello world" << endl;
};
} classManip;

function<ostream& (ostream&)> functionManip = [] (ostream& stream) -> ostream& {
return stream << "Hello world" << endl;
};

int main (int argc, char** argv) {
const string str = "Hello world";
auto lambdaManip = [&] (ostream& stream) -> ostream& {
return stream << str << endl;
};

cout << classManip;     // Compiler error
cout << lambdaManip;    // Compiler error
cout << functionManip;  // Compiler error
}

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

// Tell ostreams to interpret std::function as a
// manipulator, wherever it sees one.
inline ostream& operator<<(
ostream& stream,
const function<ostream& (ostream&)>& manipulator) {
return manipulator( stream );
}

Этот код имеет дополнительный const, Я обнаружил это, пытаясь реализовать решение в моем проекте.