c++ - 使用临时函数包装器完美转发

Question

在帖子 here 之后，考虑 C++14 中的以下代码, here和 here :

// Include
#include <tuple>
#include <iostream>
#include <type_traits>

// Temporary function queue declaration
template <class... F>
class temporary_function_queue;

// Apply function queue declaration
template <class... F>
constexpr temporary_function_queue<F&&...> apply_function_queue(F&&... f);

// Temporary function queue definition
template <class... F>
class temporary_function_queue final
{
    // Types
    private:
    using const_lvalue_reference = const temporary_function_queue&;
    using rvalue_reference = temporary_function_queue&&;
    using temporary_type = temporary_function_queue<F&&...>;
    using data_type = std::tuple<F&&...>;

    // Lifecycle
    private:
    temporary_function_queue(rvalue_reference) = default;
    temporary_function_queue(const_lvalue_reference) = delete;
    temporary_function_queue operator=(rvalue_reference) = delete;
    temporary_function_queue operator=(const_lvalue_reference) = delete;
    explicit constexpr temporary_function_queue(F&&... f)
    : _f{std::forward<F>(f)...}
    {
    }

    // Temporary creator
    public:
    friend constexpr temporary_type apply_function_queue<>(F&&... f);

    // Apply function queue declaration
    public:
    template <class... Args> 
    decltype(auto) operator()(Args&&... args) const&&
    {
        // Do I need to do std::forward on f0 too? If so, how?
        return std::get<0>(_f)(std::forward<Args>(args)...);
    }

    // Data members
    private:
    data_type _f;
};

// Apply function queue definition
template <class... F>
constexpr temporary_function_queue<F&&...> apply_function_queue(F&&... f)
{
    return temporary_function_queue<F&&...>(std::forward<F>(f)...);
}

/* Example of use
int main(int argc, char* argv[])
{
    apply_function_queue(
        [](auto i){std::cout<<0<<std::endl;},
        [](auto i){std::cout<<1<<std::endl;}
    )(0);
    return 0;
}
*/

目标是生成以下调用语法:

apply_function_queue(f0, f1, f2)(a, b, c, d, e);

f0, f1, f2 是函数指针、仿函数、lambdas...，a、b、c、d、e 是参数完美转发。这个函数应该产生一个临时类型，然后调用那个临时类型的operator()，这个操作符应该做一个完美的fn转发(现在 f0，稍后会更改)，参数为a, b, c, d, e...。 temporary_function_queue 不应在任何其他上下文中使用。

问题是我对转发、通用引用和左值引用有点迷茫……上面显示的代码安全吗？如果不是，哪个使用示例会导致未定义的行为？在这种情况下，如何使其安全、高效(理想情况下，我希望大多数使用 -O3 的编译器都没有运行时开销)？

Answer 1

注意:使用这种方法很可能会出现悬挂引用。

auto make_f(); // return by value
auto&& q = apply_function_queue(make_f());
// q holds dangling rvalue reference
q(a, b, c); // whoops...

---

首先是关于措辞和演绎的一些评论。让:

template<class... T> void f(T&&... p) {}

注意:当这个模板被实例化时，这里有两个不同的包:T...和 T&&... .

用左值调用它或输入 R和 Q 类型的右值:

R a;
f(a, Q{});

现在T...将是 R&, Q但是T&&...将是 R&, Q&& .

转发包 p将导致 T&&...打包。

'decltype'(std::forward<T>(p)...) === T&&...

(注意:您实际上不能在此处应用 decltype - 这只是为了说明。)

因此，我将实际推导的包 ( T... ) 称为 deduced types/pack 并将添加右值引用/转发 ( T&&... ) 的结果称为 转发类型/包。

---

正在申请 &&在类中的任何地方以及 apply_function_queue 的返回类型中是多余的。 (如果您从 temporary_function_queue<F&&...> 返回 apply_function_queue，则不需要在 && 中使用 temporary_function_queue。如果您在类(class)中的任何地方应用 &&，则无需返回 temporary_function_queue<F&&...>。)

您可以使用推导包实例化类模板并添加 &&在任何你想要引用的地方，我们用转发包实例化类模板，不要添加 && .

需要在类中提供可用的推导类型。 (因为 friend 声明同时使用了 F... 和 F&&... 。)因此您需要删除 &&来自 apply_function_queue 的返回类型.

您需要更改一些声明:

apply_function_queue

前向声明:

template <class... F>
constexpr temporary_function_queue<F...> apply_function_queue(F&&... f);

定义:

template <class... F>
constexpr temporary_function_queue<F...> apply_function_queue(F&&... f)
{
    return temporary_function_queue<F...>(std::forward<F>(f)...);
}

temporary_type

类实例类型为temporary_function_queue<F...>不是temporary_function_queue<F&&...> !

using temporary_type = temporary_function_queue<F...>;

好友声明

friend constexpr temporary_type apply_function_queue<F...>(F&&... f);

---

如果你想在函数调用运算符中完美转发右值函数类型，我认为你必须求助于手动转换/转发。

内部decltype(auto) operator()(Args&&... args) const&&你会发现

decltype(std::get<0>(_f)) === std::tuple_element_t<0u, data_type>&

引用折叠规则是左值引用。为了转发元组中的元素，您真正想要的是 tuple_element::type .

因此您必须直接转换为元组中的实际类型:

return static_cast<std::tuple_element_t<0u, data_type>>(
    std::get<0>(_f))(std::forward<Args>(args)...);

或转发(通过引用折叠具有相同的效果):

return std::forward<std::tuple_element_t<0u, data_type>>(
    std::get<0>(_f))(std::forward<Args>(args)...);