c++ - 如何使 C++ lambda 对象的存储更高效？

Question

我最近一直在考虑存储 C++ lambda。您在 Internet 上看到的标准建议是将 lambda 存储在 std::function 对象中。但是，这些建议都没有考虑到存储影响。我突然想到，一定有一些严肃的巫术在幕后进行才能完成这项工作。考虑以下存储整数值的类:

class Simple {
public:
    Simple( int value ) { puts( "Constructing simple!" ); this->value = value; }
    Simple( const Simple& rhs ) { puts( "Copying simple!" ); this->value = rhs.value; }
    Simple( Simple&& rhs ) { puts( "Moving simple!" ); this->value = rhs.value; }
    ~Simple() { puts( "Destroying simple!" ); }
    int Get() const { return this->value; }

private:
    int value;
};

现在，考虑这个简单的程序:

int main()
{
    Simple test( 5 );

    std::function<int ()> f =
        [test] ()
        {
            return test.Get();
        };

    printf( "%d\n", f() );
}

这是我希望从这个程序中看到的输出:

Constructing simple!
Copying simple!
Moving simple!
Destroying simple!
5
Destroying simple!
Destroying simple!

首先，我们创建值(value)测试。我们在堆栈上为临时 lambda 对象创建一个本地拷贝。然后我们将临时 lambda 对象移动到 std::function 分配的内存中。我们销毁临时 lambda。我们打印我们的输出。我们销毁 std::function。最后，我们销毁测试对象。<​​/p>

不用说，这不是我看到的。当我在 Visual C++ 2010(发布或 Debug模式)上编译它时，我得到这个输出:

Constructing simple!
Copying simple!
Copying simple!
Copying simple!
Copying simple!
Destroying simple!
Destroying simple!
Destroying simple!
5
Destroying simple!
Destroying simple!

天哪，效率低下!编译器不仅没有使用我的移动构造函数，而且在赋值过程中生成并销毁了两个明显多余的 lambda 拷贝。

所以，最后是问题:(1)所有这些复制真的有必要吗？ (2) 有没有办法强制编译器生成更好的代码？感谢阅读!

Answer 1

The standard advice you see on the Internet is to store the lambda in a std::function object. However, none of this advice ever considers the storage implications.

那是因为它不重要。您无权访问 lambda 的类型名。因此，虽然您最初可以使用 auto 将其存储在其 native 类型中，但它并没有离开该类型的范围。您不能将其作为该类型返回。你可以只把它粘在别的东西上。而 C++11 提供的唯一“其他东西”是 std::function。

所以你有一个选择:用 auto 暂时保持它，锁定在那个范围内。或者将其粘贴在 std::function 中以长期存储。

Is all this copying really necessary?

技术上？不，对于 std::function 的作用，这不是必要的。

Is there some way to coerce the compiler into generating better code?

没有。这不是你的编译器的错。这就是 std::function 的特定实现的工作原理。它可以做更少的复制；它不应该复制超过两次(取决于编译器如何生成 lambda，可能只有一次)。但确实如此。