在 lambda 中移动捕获
Move capture in lambda
如何在 C++11 lambda 中通过移动(也称为右值引用(进行捕获？
我正在尝试写这样的东西：
std::unique_ptr<int> myPointer(new int);
std::function<void(void)> example = [std::move(myPointer)]{
*myPointer = 4;
};
C++14 中的广义 lambda 捕获
在 C++14 中，我们将拥有所谓的广义 lambda 捕获。这将启用移动捕获。以下是 C++14 中的法典：
using namespace std;
// a unique_ptr is move-only
auto u = make_unique<some_type>( some, parameters );
// move the unique_ptr into the lambda
go.run( [ u = move(u) ] { do_something_with( u ); } );
另请注意，如果您需要将对象从 lambda 移动到其他函数，则需要使 lambda mutable 。
go.run( [ u = move(u) ] mutable { do_something_with( std::move(u) ); } );
广义的 lambda 捕获要通用得多，因为捕获的变量可以用如下方式初始化：
auto lambda = [value = 0] mutable { return ++value; };
在 C++11 中，这还是不可能的，但有一些涉及帮助程序类型的技巧。幸运的是，Clang 3.4编译器已经实现了这个很棒的功能。编译器将于 2013 年 12 月或 2014 年 1 月发布(如果保留最近的发布速度(。
更新：Clang 3.4编译器于2014年1月6日发布，具有上述功能。
移动捕获的解决方法
下面是帮助程序函数make_rref的实现，它有助于人工移动捕获
#include <cassert>
#include <memory>
#include <utility>
template <typename T>
struct rref_impl
{
rref_impl() = delete;
rref_impl( T && x ) : x{std::move(x)} {}
rref_impl( rref_impl & other )
: x{std::move(other.x)}, isCopied{true}
{
assert( other.isCopied == false );
}
rref_impl( rref_impl && other )
: x{std::move(other.x)}, isCopied{std::move(other.isCopied)}
{
}
rref_impl & operator=( rref_impl other ) = delete;
T && move()
{
return std::move(x);
}
private:
T x;
bool isCopied = false;
};
template<typename T> rref_impl<T> make_rref( T && x )
{
return rref_impl<T>{ std::move(x) };
}
这是在我的 gcc 4.7.3 上成功运行的函数的测试用例。
int main()
{
std::unique_ptr<int> p{new int(0)};
auto rref = make_rref( std::move(p) );
auto lambda =
[rref]() mutable -> std::unique_ptr<int> { return rref.move(); };
assert( lambda() );
assert( !lambda() );
}
这里的缺点是lambda是可复制的，并且在复制时，rref_impl 的复制构造函数中的断言失败，导致运行时错误。以下内容可能是更好、更通用的解决方案，因为编译器将捕获错误。
在 C++11 中模拟广义 lambda 捕获
这是另一个想法，关于如何实现广义 lambda 捕获。函数capture()(其实现在下面找到(的使用如下：
#include <cassert>
#include <memory>
int main()
{
std::unique_ptr<int> p{new int(0)};
auto lambda = capture( std::move(p),
[]( std::unique_ptr<int> & p ) { return std::move(p); } );
assert( lambda() );
assert( !lambda() );
}
这里lambda是一个函子对象(几乎是一个真正的 lambda(，它在传递给capture()时捕获了std::move(p)。capture的第二个参数是一个 lambda，它将捕获的变量作为参数。当 lambda 用作函数对象时，传递给它的所有参数都将作为捕获变量之后的参数转发到内部 lambda。(在我们的例子中，没有进一步的论点要转发(。从本质上讲，与上一个解决方案相同。以下是capture的实现方式：
#include <utility>
template <typename T, typename F>
class capture_impl
{
T x;
F f;
public:
capture_impl( T && x, F && f )
: x{std::forward<T>(x)}, f{std::forward<F>(f)}
{}
template <typename ...Ts> auto operator()( Ts&&...args )
-> decltype(f( x, std::forward<Ts>(args)... ))
{
return f( x, std::forward<Ts>(args)... );
}
template <typename ...Ts> auto operator()( Ts&&...args ) const
-> decltype(f( x, std::forward<Ts>(args)... ))
{
return f( x, std::forward<Ts>(args)... );
}
};
template <typename T, typename F>
capture_impl<T,F> capture( T && x, F && f )
{
return capture_impl<T,F>(
std::forward<T>(x), std::forward<F>(f) );
}
第二种解决方案也更干净，因为如果捕获的类型不可复制，它将禁用复制 lambda。在第一个只能在运行时使用assert()检查的解决方案中。
您也可以使用 std::bind 来捕获unique_ptr：
std::function<void()> f = std::bind(
[] (std::unique_ptr<int>& p) { *p=4; },
std::move(myPointer)
);
您可以使用
std::bind实现大部分您想要的东西，如下所示：
std::unique_ptr<int> myPointer(new int{42});
auto lambda = std::bind([](std::unique_ptr<int>& myPointerArg){
*myPointerArg = 4;
myPointerArg.reset(new int{237});
}, std::move(myPointer));
这里的诀窍是，我们不是在捕获列表中捕获仅移动对象，而是将其作为参数，然后通过std::bind使用部分应用程序使其消失。 请注意，lambda 通过引用获取它，因为它实际上存储在绑定对象中。 我还添加了写入实际可移动对象的代码，因为这是您可能想要做的事情。
在 C++14 中，您可以使用通用 lambda 捕获来实现相同的目的，代码如下：
std::unique_ptr<int> myPointer(new int{42});
auto lambda = [myPointerCapture = std::move(myPointer)]() mutable {
*myPointerCapture = 56;
myPointerCapture.reset(new int{237});
};
但是这段代码不会通过 std::bind 购买您在 C++11 中没有的任何东西。 (在某些情况下，广义 lambda 捕获功能更强大，但在这种情况下并非如此。
现在只有一个问题;你想把这个函数放在一个std::function中，但该类要求该函数是CopyConstructible的，但它不是，它只是MoveConstructible，因为它存储了一个不是CopyConstructible std::unique_ptr。
您可以使用包装类和另一个间接级别来解决此问题，但也许您根本不需要std::function。根据您的需要，您可以使用std::packaged_task;它将做与std::function相同的工作，但它不需要函数是可复制的，只能是可移动的(同样，std::packaged_task只能移动(。 缺点是因为它打算与 std：：future 结合使用，所以您只能调用它一次。
这是一个简短的程序，展示了所有这些概念。
#include <functional> // for std::bind
#include <memory> // for std::unique_ptr
#include <utility> // for std::move
#include <future> // for std::packaged_task
#include <iostream> // printing
#include <type_traits> // for std::result_of
#include <cstddef>
void showPtr(const char* name, const std::unique_ptr<size_t>& ptr)
{
std::cout << "- &" << name << " = " << &ptr << ", " << name << ".get() = "
<< ptr.get();
if (ptr)
std::cout << ", *" << name << " = " << *ptr;
std::cout << std::endl;
}
// If you must use std::function, but your function is MoveConstructable
// but not CopyConstructable, you can wrap it in a shared pointer.
template <typename F>
class shared_function : public std::shared_ptr<F> {
public:
using std::shared_ptr<F>::shared_ptr;
template <typename ...Args>
auto operator()(Args&&...args) const
-> typename std::result_of<F(Args...)>::type
{
return (*(this->get()))(std::forward<Args>(args)...);
}
};
template <typename F>
shared_function<F> make_shared_fn(F&& f)
{
return shared_function<F>{
new typename std::remove_reference<F>::type{std::forward<F>(f)}};
}
int main()
{
std::unique_ptr<size_t> myPointer(new size_t{42});
showPtr("myPointer", myPointer);
std::cout << "Creating lambdan";
#if __cplusplus == 201103L // C++ 11
// Use std::bind
auto lambda = std::bind([](std::unique_ptr<size_t>& myPointerArg){
showPtr("myPointerArg", myPointerArg);
*myPointerArg *= 56; // Reads our movable thing
showPtr("myPointerArg", myPointerArg);
myPointerArg.reset(new size_t{*myPointerArg * 237}); // Writes it
showPtr("myPointerArg", myPointerArg);
}, std::move(myPointer));
#elif __cplusplus > 201103L // C++14
// Use generalized capture
auto lambda = [myPointerCapture = std::move(myPointer)]() mutable {
showPtr("myPointerCapture", myPointerCapture);
*myPointerCapture *= 56;
showPtr("myPointerCapture", myPointerCapture);
myPointerCapture.reset(new size_t{*myPointerCapture * 237});
showPtr("myPointerCapture", myPointerCapture);
};
#else
#error We need C++11
#endif
showPtr("myPointer", myPointer);
std::cout << "#1: lambda()n";
lambda();
std::cout << "#2: lambda()n";
lambda();
std::cout << "#3: lambda()n";
lambda();
#if ONLY_NEED_TO_CALL_ONCE
// In some situations, std::packaged_task is an alternative to
// std::function, e.g., if you only plan to call it once. Otherwise
// you need to write your own wrapper to handle move-only function.
std::cout << "Moving to std::packaged_taskn";
std::packaged_task<void()> f{std::move(lambda)};
std::cout << "#4: f()n";
f();
#else
// Otherwise, we need to turn our move-only function into one that can
// be copied freely. There is no guarantee that it'll only be copied
// once, so we resort to using a shared pointer.
std::cout << "Moving to std::functionn";
std::function<void()> f{make_shared_fn(std::move(lambda))};
std::cout << "#4: f()n";
f();
std::cout << "#5: f()n";
f();
std::cout << "#6: f()n";
f();
#endif
}
我已经在 Coliru 上放了一个上面的程序，所以你可以运行和玩代码。
以下是一些典型的输出...
- &myPointer = 0xbfffe5c0, myPointer.get() = 0x7ae3cfd0, *myPointer = 42
Creating lambda
- &myPointer = 0xbfffe5c0, myPointer.get() = 0x0
#1: lambda()
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfd0, *myPointerArg = 42
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfd0, *myPointerArg = 2352
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 557424
#2: lambda()
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 557424
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 31215744
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfd0, *myPointerArg = 3103164032
#3: lambda()
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfd0, *myPointerArg = 3103164032
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfd0, *myPointerArg = 1978493952
- &myPointerArg = 0xbfffe5b4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 751631360
Moving to std::function
#4: f()
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 751631360
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 3436650496
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3d000, *myPointerArg = 2737348608
#5: f()
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3d000, *myPointerArg = 2737348608
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3d000, *myPointerArg = 2967666688
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 3257335808
#6: f()
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 3257335808
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 2022178816
- &myPointerArg = 0x7ae3cfd4, myPointerArg.get() = 0x7ae3d000, *myPointerArg = 2515009536
您可以看到堆位置被重用，表明std::unique_ptr工作正常。当我们将其存储在我们提供给std::function的包装器中时，您还会看到函数本身四处移动。
如果我们切换到使用 std::packaged_task ，最后一部分变为
Moving to std::packaged_task
#4: f()
- &myPointerArg = 0xbfffe590, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 751631360
- &myPointerArg = 0xbfffe590, myPointerArg.get() = 0x7ae3cfe0, *myPointerArg = 3436650496
- &myPointerArg = 0xbfffe590, myPointerArg.get() = 0x7ae3d000, *myPointerArg = 2737348608
因此，我们看到函数已被移动，但它不是移动到堆上，而是在堆栈上的std::packaged_task内。
希望这有帮助！
晚了，但由于有些人(包括我(仍然坚持使用 c++11：
老实说，我真的不喜欢任何已发布的解决方案。我相信它们会起作用，但它们需要很多额外的东西和/或神秘的std::bind语法......而且我认为不值得为这样一个临时解决方案付出努力，该解决方案在升级到 c ++>= 14 时无论如何都会被重构。所以我认为最好的解决方案是完全避免 c++11 的移动捕获。
通常最简单和最易读的解决方案是使用std::shared_ptr，这是可复制的，因此移动是完全可以避免的。缺点是，它的效率有点低，但在许多情况下，效率并不那么重要。
// myPointer could be a parameter or something
std::unique_ptr<int> myPointer(new int);
// convert/move the unique ptr into a shared ptr
std::shared_ptr<int> mySharedPointer( std::move(myPointer) );
std::function<void(void)> = [mySharedPointer](){
*mySharedPointer = 4;
};
// at end of scope the original mySharedPointer is destroyed,
// but the copy still lives in the lambda capture.
.
如果发生非常罕见的情况，确实必须move指针(例如，由于删除持续时间过长，您希望显式删除单独线程中的指针，或者性能绝对至关重要(，这几乎是我仍然在 c++11 中使用原始指针的唯一情况。这些当然也是可复制的。
通常，我用//FIXME:标记这些罕见的情况，以确保在升级到c ++ 14后对其进行重构。
// myPointer could be a parameter or something
std::unique_ptr<int> myPointer(new int);
//FIXME:c++11 upgrade to new move capture on c++>=14
// "move" the pointer into a raw pointer
int* myRawPointer = myPointer.release();
// capture the raw pointer as a copy.
std::function<void(void)> = [myRawPointer](){
std::unique_ptr<int> capturedPointer(myRawPointer);
*capturedPointer = 4;
};
// ensure that the pointer's value is not accessible anymore after capturing
myRawPointer = nullptr;
是的，这些天原始指针非常不受欢迎(并非没有原因(，但我真的认为在这些罕见(和临时！(的情况下，它们是最好的解决方案。
这
似乎适用于 gcc4.8
#include <memory>
#include <iostream>
struct Foo {};
void bar(std::unique_ptr<Foo> p) {
std::cout << "barn";
}
int main() {
std::unique_ptr<Foo> p(new Foo);
auto f = [ptr = std::move(p)]() mutable {
bar(std::move(ptr));
};
f();
return 0;
}
我正在看这些答案，但我发现绑定很难阅读和理解。 所以我所做的是制作一个在副本上移动的类。 这样，它正在做什么是明确的。
#include <iostream>
#include <memory>
#include <utility>
#include <type_traits>
#include <functional>
namespace detail
{
enum selection_enabler { enabled };
}
#define ENABLE_IF(...) std::enable_if_t<(__VA_ARGS__), ::detail::selection_enabler>
= ::detail::enabled
// This allows forwarding an object using the copy constructor
template <typename T>
struct move_with_copy_ctor
{
// forwarding constructor
template <typename T2
// Disable constructor for it's own type, since it would
// conflict with the copy constructor.
, ENABLE_IF(
!std::is_same<std::remove_reference_t<T2>, move_with_copy_ctor>::value
)
>
move_with_copy_ctor(T2&& object)
: wrapped_object(std::forward<T2>(object))
{
}
// move object to wrapped_object
move_with_copy_ctor(T&& object)
: wrapped_object(std::move(object))
{
}
// Copy constructor being used as move constructor.
move_with_copy_ctor(move_with_copy_ctor const& object)
{
std::swap(wrapped_object, const_cast<move_with_copy_ctor&>(object).wrapped_object);
}
// access to wrapped object
T& operator()() { return wrapped_object; }
private:
T wrapped_object;
};
template <typename T>
move_with_copy_ctor<T> make_movable(T&& object)
{
return{ std::forward<T>(object) };
}
auto fn1()
{
std::unique_ptr<int, std::function<void(int*)>> x(new int(1)
, [](int * x)
{
std::cout << "Destroying " << x << std::endl;
delete x;
});
return [y = make_movable(std::move(x))]() mutable {
std::cout << "value: " << *y() << std::endl;
return;
};
}
int main()
{
{
auto x = fn1();
x();
std::cout << "object still not deletedn";
x();
}
std::cout << "object was deletedn";
}
move_with_copy_ctor类及其帮助程序函数make_movable()将适用于任何可移动但不可复制的对象。 要访问包装的对象，请使用operator()() 。
预期产出：
值：1对象仍未删除值：1销毁 000000DFDD172280对象已删除
好吧，指针地址可能会有所不同。 ;)
演示
Lambda 只是匿名函数对象的语法糖。您可以只声明一个函数本地struct并提供一个operator()成员：
void someFunction(std::unique_ptr<Foo> foo)
{
struct Anonymous
{
std::unique_ptr<Foo> ptr;
void operator()()
{
ptr->doSomething();
}
};
std::function<void(void)> f = Anonymous{std::move(foo)};
}
要捕获更多变量，只需向结构添加更多成员变量并在实例化时初始化它们。
我知道这很啰嗦。但这是一个可行的替代方案，可以在 C++11 中工作，而无需诉诸一堆黑客、元编程或std::bind .
的变体也可以用于代替泛型 lambda，但 C++11 不允许在函数本地结构中使用成员函数模板，因此结构已在类、命名空间或全局范围内声明。
相关文章：
- 使lambda不可复制/不可移动
- 从具有按值捕获的 lambda 移动构造 std::函数时，移动构造函数调用两次
- 传递具有移动捕获功能的 lambda
- 我应该如何正确地将packaged_task移动到 lambda?
- 使用参数将仅可移动对象捕获到 lambda
- 如果唯一指针是捕获的值，为什么它不能在 lambda 内移动？
- 从已移动捕获的 lambda 中重复移动变量
- 是否可以传递具有捕获的不可复制(移动）值的 lambda
- 当使用 std::move 和 lambda 时，何时会发生移动
- 将函数移动到线程(使用 lambda）时内存泄漏
- 为什么可以移动不可用的lambda捕获
- 为什么在Lambda移动时未调用移动构造函数
- 在可移动类型的构造函数 lambda 中捕获此内容的安全使用
- lambda是如何移动的
- 在 lambda 闭包上应用移动
- 如何将变量移动到 lambda 表达式中
- 安全地移动在访问其他成员的成员线程中运行 lambda 的对象
- 捕获并移动 c++14 lambda 表达式中的unique_ptr
- 移动 lambda：一旦您捕获了仅移动类型，如何使用 lambda？
- 捕获和调试对移动lambda内部局部变量引用的无效使用
