将返回多态 unique_ptr 的 lambda 作为函数指针传递

Question

我想传递一个非捕获 lambda，它返回一个 std::unique_ptr<Derived>，作为std::unique_ptr<Base>(*)()类型的函数指针。

但是，这仅在我将 lambda 的返回类型明确声明为 std::unique_ptr<Base> 时才有效。

• 为什么我要明确声明返回类型？
• 为什么它适用于没有这种额外返回类型的std::function？

---

#include <functional>
#include <memory>

struct Base{virtual ~Base()=default;};
struct Derived : Base{};

struct FailsForF2
{
   using Function = std::add_pointer_t<std::unique_ptr<Base>()>;
   FailsForF2(Function f) {}
};

struct Works
{
   using Function = std::function<std::unique_ptr<Base>()>;
   Works(Function f) {}
};


std::unique_ptr<Derived> fun() {return std::make_unique<Derived>();} 

int main()
{

   auto f1 = [](){return std::make_unique<Base>();};
   auto f2 = [](){return std::make_unique<Derived>();};
   auto f3 = []()->std::unique_ptr<Base>{return std::make_unique<Derived>();};

   Works x1(f1);
   Works x2(f2);
   Works x3(f3);

   FailsForF2 x4(f1);
   FailsForF2 x5(f2);
   FailsForF2 x6(f3);
}

gcc 错误：

main.cpp: In function 'int main()':

main.cpp:34:20: error: invalid user-defined conversion from 'main()::<lambda()>' to 'FailsForF2::Function {aka std::unique_ptr<Base> (*)()}' [-fpermissive]

    FailsForF2 x5(f2);

                    ^

main.cpp:26:17: note: candidate is: main()::<lambda()>::operator std::_MakeUniq<Derived>::__single_object (*)()() const <near match>

    auto f2 = [](){return std::make_unique<Derived>();};

                 ^

main.cpp:26:17: note:   no known conversion from 'std::_MakeUniq<Derived>::__single_object (*)() {aka std::unique_ptr<Derived> (*)()}' to 'FailsForF2::Function {aka std::unique_ptr<Base> (*)()}'

main.cpp:10:4: note:   initializing argument 1 of 'FailsForF2::FailsForF2(FailsForF2::Function)'

    FailsForF2(Function f) {}

live example

Answer 1

TL;DR;

• FailsForF2 失败，因为 std::unique_ptr<Derived> (*) () 不能隐式转换为 std::unique_ptr<Base> (*) ()；
• Works 有效，因为 std::unique_ptr<Derived> 可以隐式转换为 std::unique_ptr<Base>（请参阅末尾的标准引号）。

---

一个 lambda 可以隐式转换为具有相同返回类型和参数的函数指针¹，因此您的三个 lambda 可以分别转换为：

std::unique_ptr<Base> (*) ()
std::unique_ptr<Derived> (*) ()
std::unique_ptr<Base> (*) ()

由于std::unique_ptr<Derived> (*) () 与std::unique_ptr<Base> (*) () 不同（并且不能转换为）FailsForF2 构造函数没有可行的重载。请参阅以下代码：

std::unique_ptr<Derived> (*pfd) () = f2; // Compiles.
std::unique_ptr<Base> (*pfb) () = pfd;   // Does not compile (invalid conversion).

当你显式指定 lambda 的返回类型时，你改变了 lambda 的调用运算符的返回类型（实际上是与之关联的闭包类型，见最后的引用），所以转换是可能的。

---

另一方面，std::function 没有这样的约束 - std::function 的构造函数是模板化的，因此它可以接受任何可调用的：

template <typename F>
std::function(F &&f);

...只要以下有效²：

INVOKE(f, std::forward<Args>(args)..., R)

---

_{¹ 来自 N4594，§5.1.5/7 的标准引用（重点是我的）：}

_{不带 lambda 捕获的非泛型 lambda 表达式的闭包类型有一个转换函数，指向具有 相同参数和返回类型的 C++ 语言链接 (7.5) 的函数的指针 作为 闭包类型的函数调用运算符。 [...]}

_{² 来自 N4594，§20.12.12.2/2 的标准引用：}

_{如果表达式INVOKE (f, declval<ArgTypes>()..., R)（被认为是未计算的操作数（第 5 条））格式正确（20.12.2），则 F 类型的可调用对象 f 对于参数类型 ArgTypes 和返回类型 R 是可调用的。}

_{...和 ​​§20.12.2（重点是我的，1.1 到 1.6 是关于指向成员函数的指针（或类似内容），因此这里不相关）：}

_{¹ 定义INVOKE (f, t1, t2, ..., tN)如下：}

_{(1.x) - [...]}

_{^(1.7) - f(t1, t2, ..., tN) 在所有其他情况下。}

_{² 定义INVOKE (f, t1, t2, ..., tN, R)为static_cast(INVOKE (f, t1, t2, ..., tN))如果R是cv void，否则INVOKE (f, t1, t2, ..., tN)隐式转换为R。}

Answer 2

除了 Holt 的回答，并涵盖您的第一个问题：您不必将返回类型显式指定为尾随返回类型。但是由于您正在创建一个unique_ptr<Derived>，但想要一个unique_ptr<Base>，您应该返回后者并在您的函数中执行转换。

所以，我相信，这就是

auto f2 = [](){ return std::unique_ptr<Base>{new Derived()}; };

也可以编译。