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

Question

考虑 C++14 中的以下代码，在帖子 , and 之后：

// 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...）称为推导的types/pack和添加右值引用/转发的结果(T&&...)转发types/pack.

在 class 以及 apply_function_queue 的 return 类型中到处应用 && 是多余的。（如果你从 apply_function_queue return temporary_function_queue<F&&...> 就不需要 && 在 temporary_function_queue 里面。如果你在 class到处都不需要returntemporary_function_queue<F&&...>.)

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

需要在 class 中提供可用的推导类型。（因为 friend 声明同时使用了 F... 和 F&&...。）因此您需要从 apply_function_queue 的 return 类型中删除 &&。

您需要更改一些声明：

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

class 实例类型是 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)...);

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

Perfect forwarding with a temporary function wrapper

c++

templates

c++14

template-meta-programming

perfect-forwarding