C++ lambda内部std:：shared_ptr的锁定复制操作

对于此示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <memory>

struct A
{
    int _i;
    A(int i):_i(i)
    {
        std::cout<<"A() "<<_i<<std::endl;
    }
    ~A()
    {
        std::cout<<"~A() "<<_i<<std::endl;
    }
    void Print()
    {
        std::cout<<"Print() "<<_i<<std::endl;
    }
};

struct B
{
    std::shared_ptr<A> Asp;
    std::mutex AspMutex;

    void SetA()
    {
        static int i = 0;
        std::unique_lock<std::mutex> lock(AspMutex);
        Asp = std::make_shared<A>(i);
    }

    void AccessA1()
    {
        std::shared_ptr<A> aspCopy;
        {
            std::unique_lock<std::mutex> lock(AspMutex);
            aspCopy = Asp;
        }
        (*aspCopy).Print();
    }

    void AccessA2()
    {
        auto aspCopy = [&]()
        {
            std::unique_lock<std::mutex> lock(AspMutex);
            return Asp;
        }();
        (*aspCopy).Print();
    }

    void AccessA3()
    {
        (*[&]()
        {
            std::unique_lock<std::mutex> lock(AspMutex);
            return Asp;
        }()
        ).Print();
    }

};

int main()
{
    B b;
    b.SetA();
    std::thread t([&]{b.SetA();});
    b.AccessA1();
    b.AccessA2();
    b.AccessA3();
    t.join();
}

#包括
#包括
#包括
#包括
结构A
{
int_i；
A（内部i）：_i（i）
{
std:：cout是的。锁使
A:：Access1
和
A:：Access2
与并发
SetA
保持线程安全。这在C++17中仍然是正确的。
你能解释一下它目前什么是线程安全的吗？因为看起来你在锁后面访问
Asp
。我不明白这个问题。你锁，然后复制。为什么那不是线程安全吗？编辑：没关系，我错过了
b.SetA（）
之前的
std:：thread
@nicolabolas，据我所知什么都没有。我只是好奇它是否有任何危险。例如
Access2
中的Lambda不能复制
shared\u ptr
而是使用原始的。