Question

我正在尝试使用C ++ 11功能来使自定义流操作符更容易创建。我可以使用lambda函数作为操纵符，但不能使用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。但我确实希望编写返回lambda函数的函数，并且不知道如何在没有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。我发现这试图在我的项目中实际实现解决方案。

Answer 1

如果你operator<<查看ostream，那么std::function就没有超载了 - 这基本上就是你在cout << functionManip尝试做的事情。要解决此问题，请自行定义过载：

ostream& operator<<(ostream& os, std::function<ostream& (ostream&)>& s)
{
    return s(os);
}

或者将stream作为参数传递给函数：

functionManip(std::cout);

至于为什么lambda正在工作，假设lambda的返回类型未定义，并且使用函数指针存在重载：

ostream& operator<< (ostream& ( *pf )(ostream&));

lambda可能使用结构包装所有内容并定义operator()，在这种情况下它将完全像函数指针一样工作。这对我来说是最可能的解释，希望如果我错了，有人可以纠正我。

Answer 2

这不是导致错误的原因，但由于您已将lambdaManip和functionManip定义为返回类型ostream&，我相信您忘记添加{ {1}}两者都有。

调用return stream;失败，因为没有定义cout << functionManip。添加一个，呼叫将成功。

operator<<(ostream&, std::function<ostream&(ostream&)>

或者，您可以将ostream& operator<<(ostream& stream, function<ostream& (ostream&)>& func) { return func( stream ); }称为

functionManip

这可以在不添加functionManip( cout );定义的情况下工作。

关于返回lambda的问题，由于operator<<返回的lambda是一个无捕获的lambda，它可以隐式转换为函数指针。

getAdditionFunctor

Answer 3

以前的答案是最先进的，但是如果您要在代码中使用std::function和/或lambdas作为流操作符那么你可能会只想在全局范围内将以下函数模板定义添加到代码库中：

template<class M>
auto operator<< (std::ostream& os, const M& m) -> decltype(m(os))
{
    return m(os);
}

使用expression SFINAE的尾随返回类型，因此除非operator<<是格式正确的表达式，否则此特定m(os)重载甚至不会参与重载决策。（这就是你想要的。）

然后你甚至可以做像

这样的事情

template<class T>
auto commaize(const T& t)
{
    return [&t](std::ostream& os) -> std::ostream& {
        return os << t << ", ";
    };
}

int main()
{
    std::cout << commaize("hello") << commaize("darling") << std::endl;
}

（注意上面代码中完全缺少任何std::function个对象！尽量避免将lambda填充到std::function个对象中，除非你必须这样做，因为构造一个std::function对象可以是昂贵;甚至可能涉及内存分配。）

C ++ 17将这个operator<<重载添加到标准库是有意义的，但我目前还不知道该领域有任何具体的提议。

std :: function作为自定义流操纵器

3 个答案: