我正在实现我自己的类，该类提供其成员的惰性初始化。而且我遇到了在 lambda 中捕获 this 的奇怪行为。

这是一个重现此错误的示例。

//Baz.h
#include <memory>
#include <functional>
#include "Lazy.hpp"

struct Foo
{
    std::string str;

    Foo() = default;
    Foo(std::string str) : str(str) {}
    Foo(Foo&& that) : str(that.str) {  }
};

class Baz
{
    std::string str;

    Lazy<std::unique_ptr<Foo>> foo;

public:
    Baz() = default;
    Baz(const std::string& str) : str(str)
    {
        //lazy 'this->foo' initialization. 
        //Is capturing of 'this' valid inside ctors???.
        this->foo = { [this] { return buildFoo(); } };
    }
    Baz(Baz&& that) : foo(std::move(that.foo)), str(that.str) { }

    std::string getStr() const
    {
        return this->foo.get()->str;
    }

private:
    std::unique_ptr<Foo> buildFoo()
    {
        //looks like 'this' points to nothing here.
        return std::make_unique<Foo>(str); //got error on this line
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    ///Variant 1 (lazy Foo inside regular Baz):
    Baz baz1("123");
    auto str1 = baz1.getStr();

    ///Variant 2 (lazy Foo inside lazy Baz):
    Lazy<Baz> lazy_baz = { [](){ return Baz("123"); } };
    auto& baz2 = lazy_baz.get(); //get() method returns 'inst' member (and initialize it if it's not initialized) see below
    auto str2 = baz2.getStr();

    return 0;
}

变体 1 运行良好。

变体 2 因以下错误而崩溃:

Unhandled exception at 0x642DF4CB (msvcr120.dll) in lambda_this_capture_test.exe: 0xC0000005: Access violation reading location 0x00E0FFFC.

我正在使用 vc++120 编译器(来自 VS2013)。

这是我简化的 Lazy 类:

#pragma once
#include <memory>
#include <atomic>
#include <mutex>
#include <functional>
#include <limits>

template<
    class T,
        typename = std::enable_if_t<
        std::is_move_constructible<T>::value &&
        std::is_default_constructible<T>::value
        >
>
class Lazy
{
    mutable std::unique_ptr<T> inst;
    std::function<T(void)> func;
    mutable std::atomic_bool initialized;
    mutable std::unique_ptr<std::mutex> mutex;

public:
    Lazy()
        : mutex(std::make_unique<std::mutex>())
        , func([]{ return T(); })
    {
        this->initialized.store(false);
    }

    Lazy(std::function<T(void)> func)
        : func(std::move(func))
        , mutex(std::make_unique<std::mutex>())
    {
        this->initialized.store(false);
    }
//... <move ctor + move operator>
    T& get() const
    {
        if (!initialized.load())
        {
            std::lock_guard<std::mutex> lock(*mutex);

            if (!initialized.load())
            {
                inst = std::make_unique<T>(func());
                initialized.store(true);
            }
        }

        return *inst;
    }
};

所以我的问题是:为什么这个例子会崩溃？在构造函数中捕获 this 是否有效？

最佳答案

一般来说，捕获this是有效的在构造函数中。但是这样做时，您必须确保 lambda 不会超过 this 的对象。它捕获了。否则，捕获 this变成悬空指针。

这正是您的情况。 Baz谁的this被捕获的是在main 内部构建的临时-scoped lambda(由 return Baz("123") 创建的。然后，当在 Baz 中创建 Lazy<Baz> 时，std::function 从临时 Baz 移动到 Baz 指向的 Lazy<Baz>::inst ， 但是移动 lambda 的捕获的 this 仍然指向原始的临时 Baz 对象。然后该对象超出范围并且砰，你有一个悬空指针。

Donghui Zhang 的评论下面(使用 enable_shared_from_this 并捕获 shared_ptr 除了 this )为您的问题提供了一个潜在的解决方案。你的Lazy<T>类存储 T std::unique_ptr<T> 拥有的实例.如果将仿函数签名更改为 std::function<std::unique_ptr<T>()> ，你将摆脱这个问题，因为惰性初始化器创建的对象将与存储在 Lazy 中的对象相同。 ，所以捕获 this不会过早过期。

关于c++ - Lambda 的 "this"捕获返回垃圾，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40043597/