c++ - 使用临时功能包装器完美转发

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

// 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的编译器没有运行时开销)？

最佳答案

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

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...)称为推导的类型/包，将添加右值引用/转发(T&&...)的结果称为转发的类型/包。

在类内部以及在&&的返回类型中的任何地方都应用apply_function_queue是多余的。 (如果从temporary_function_queue<F&&...>返回apply_function_queue，则在&&中不需要temporary_function_queue。并且，如果您在所有类中都将&&应用于该类中，则无需返回temporary_function_queue<F&&...>。)

您要么使用推导包实例化类模板，然后在要引用的任何地方添加&&，要么使用转发包实例化类模板，而不添加&&。

要求在类中具有可用的推导类型。 (因为 friend 声明同时使用了F...和F&&...。)因此，您需要从&&的返回类型中删除apply_function_queue。

您需要更改一些声明:

apply_function_queue

前向声明(forward declaration):

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 声明

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)...);

关于c++ - 使用临时功能包装器完美转发，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/42034498/