lucidbrot's questions

还有类似的问题：

• 传递超出范围的“按值” lambda 是否安全？

  • 是的，因为闭包被复制/移动了

• 我应该通过 const 引用传递 lambda 吗？

  • 是的，这对于避免复制状态很有用。但你不能传递可变的 lambda，因为它有一个非常量operator()

我的问题是两者的混合：
有一个存储类，它通过引用获取 lambda 并以某种方式存储它，使用的方法签名类似于链接的问题：

template <class Function>
void storeCallback(const Function& f)

按以下方式调用是否安全？

void foo(Storage& o) {
  o.storeCallback([](){std::cout << "hi!";});
}

void bar(Storage& o){
  o.callCallback();
}

我看到的风险是 lambda 一旦返回就会超出范围foo。那么将来调用存储的回调时，引用会无效吗？

在我感兴趣的特定情况下，这引发了这个问题，lambda 在存储类中存储的具体方式是，它被传递给另一个以std::function值作为参数的方法。这种从引用到转换的方式是否以std::function某种方式使其安全？或者它已经是安全的，与存储方式无关？

文档std::function 指出​

的实例std::function可以存储、复制和调用任何 CopyConstructible Callable 目标——函数（通过指向其的指针）、lambda 表达式、绑定表达式或其他函数对象，以及指向成员函数的指针和指向数据成员的指针。

在我看来，这听起来很std::function安全，因为无论如何它都会复制 lambda，即使它是通过引用传递的。

在没有继承的类中，我预计该virtual关键字不会产生明显的影响。但是，在下面的代码示例中，添加它会破坏编译。我想了解背后的机制。为什么该virtual关键字会破坏编译？

没有 virtual 关键字它编译得很好。

#define USE_VIRTUAL 1
// compile with: cl /W4 /EHsc main.cpp /link /out:main.exe
#include<iostream>
#include<memory>

struct Dummy {int i = 3;};
class Uncopyable {
    public:
        // Implicitly delete the copy constructor by having
        // a non-copyable member.
        std::unique_ptr<Dummy> m_innerPtr;

        // A virtual destructor to allow correct inheritance.
        // I first thought that this implicitly deletes the 
        // copy-assignment and copy-constructor, 
        // but it does not. It does, however, implicitly
        // delete the move constructor and assignment.
        virtual ~Uncopyable() = default;

        // accessible constructor
        Uncopyable() = default;
        Uncopyable(std::unique_ptr<Dummy> dummy):m_innerPtr(std::move(dummy)){};

};


template <typename MaybeCopyable>
class Bamboozle {
    public: 
    void foo(std::shared_ptr<MaybeCopyable> obj) {
        std::cout << "Reached Bamboozle::foo(shared_ptr)" << std::endl;
    }

    // overload that takes an object by value
#if USE_VIRTUAL
    virtual
#endif
    void foo(MaybeCopyable obj){
        std::cout << "Reached Bamboozle::foo(Uncopyable)" << std::endl;
        foo(std::make_shared<Uncopyable>(std::move(obj)));
    }
};



int main(int argc, char** argv){
    // construct param objects
    std::shared_ptr<Uncopyable> uncSharedPtr = std::make_shared<Uncopyable>();

    // prints Bamboozle::foo(shared_ptr)
    Bamboozle<Uncopyable> bamboozleObj;
    bamboozleObj.foo(uncSharedPtr);
    return 0;
};

如果您想了解我认为与此有关的其他方面，请参阅此问题（由于太详细而关闭）以了解更多背景信息。特别是模板和移动构造函数。类模板是重现此行为所必需的。

错误消息是：

cl /W4 /EHsc main.cpp /link /out:main.exe
Microsoft (R) C/C++ Optimizing Compiler Version 19.38.33134 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

main.cpp
main.cpp(46): warning C4100: 'argv': unreferenced formal parameter
main.cpp(46): warning C4100: 'argc': unreferenced formal parameter
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): error C2280: 'Uncopyable::Uncopyable(const Uncopyable &)': attempting to reference a deleted function
main.cpp(24): note: compiler has generated 'Uncopyable::Uncopyable' here
main.cpp(24): note: 'Uncopyable::Uncopyable(const Uncopyable &)': function was implicitly deleted because a data member invokes a deleted or inaccessible function 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)'
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(3319): note: 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)': function was explicitly deleted
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): note: the template instantiation context (the oldest one first) is
main.cpp(51): note: see reference to class template instantiation 'Bamboozle<Uncopyable>' being compiled
main.cpp(38): note: while compiling class template member function 'void Bamboozle<Uncopyable>::foo(MaybeCopyable)'
        with
        [
            MaybeCopyable=Uncopyable
        ]
main.cpp(40): note: see reference to function template instantiation 'std::shared_ptr<Uncopyable> std::make_shared<Uncopyable,Uncopyable>(Uncopyable &&)' being compiled
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2769): note: see reference to function template instantiation 'std::_Ref_count_obj2<_Ty>::_Ref_count_obj2<_Ty>(_Ty &&)' being compiled
        with
        [
            _Ty=Uncopyable
        ]
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2094): note: see reference to function template instantiation 'void std::_Construct_in_place<_Ty,_Ty>(_Ty &,_Ty &&) noexcept(false)' being compiled
        with
        [
            _Ty=Uncopyable
        ]