考虑以下函数 accept采用 T 类型的“通用引用”并将其转发给 parse<T>()具有左值重载和右值重载的函数对象:

template<class T>
void accept(T&& arg)
{
    parse<T>()(std::forward<T>(arg), 0); // copy or move, depending on rvaluedness of arg
}

template<class T>
class parse
{
    // parse will modify a local copy or move of its input parameter
    void operator()(T const& arg, int n) const { /* optimized for lvalues */ }
    void operator()(T&& arg)    , int n) const { /* optimized for rvalues */ }
};

由于完美转发使源对象处于有效但未定义的状态，因此不可能在同一范围内再次完美转发。下面我尝试在假设的 split() 中拥有尽可能少的拷贝接受 int 的函数表示必须对输入数据进行的遍数:

template<class T>
void split(T&& arg, int n)
{
    for (auto i = 0; i < n - 1; ++i)
        parse<T>()(arg , i);                 // copy n-1 times
    parse<T>()(std::forward<T>(arg), n - 1); // possibly move the n-th time
}

问题:这是对同一数据的多次传递应用完美转发的推荐方法吗？如果不是，有什么更惯用的方法可以最大程度地减少拷贝数？

最佳答案

Question: is this the recommended way to apply perfect forwarding for multiple passes over the same data?

是的，当你需要多次传递数据时，这是应用完美转发(或 move )的推荐方式。仅(可能)在您上次访问时离开它。事实上，这种情况在 original move paper 中就已经预见到了。 ，并且非常原因是声明为右值引用类型的“命名”变量不会被隐式移出。来自 N1377 :

Even though named rvalue references can bind to an rvalue, they are treated as lvalues when used. For example:

struct A {};

void h(const A&);
void h(A&&);

void g(const A&);
void g(A&&);

void f(A&& a)
{
    g(a);  // calls g(const A&)
    h(a);  // calls h(const A&)
}

Although an rvalue can bind to the "a" parameter of f(), once bound, a is now treated as an lvalue. In particular, calls to the overloaded functions g() and h() resolve to the const A& (lvalue) overloads. Treating "a" as an rvalue within f would lead to error prone code: First the "move version" of g() would be called, which would likely pilfer "a", and then the pilfered "a" would be sent to the move overload of h().

如果你想要h(a)要在上面的示例中 move ，您必须明确地这样做:

    h(std::move(a));  // calls h(A&&);

作为Casey在评论中指出，您在传递左值时遇到了重载问题:

#include  <utility>
#include  <type_traits>

template<class T>
class parse
{
    static_assert(!std::is_lvalue_reference<T>::value,
                               "parse: T can not be an lvalue-reference type");
public:
    // parse will modify a local copy or move of its input parameter
    void operator()(T const& arg, int n) const { /* optimized for lvalues */ }
    void operator()(T&& arg     , int n) const { /* optimized for rvalues */ }
};

template<class T>
void split(T&& arg, int n)
{
    typedef typename std::decay<T>::type Td;
    for (auto i = 0; i < n - 1; ++i)
        parse<Td>()(arg , i);                 // copy n-1 times
    parse<Td>()(std::forward<T>(arg), n - 1); // possibly move the n-th time
}

上面我已经按照 Casey 的建议修复了它，方法是实例化 parse<T>仅在非引用类型上使用 std::decay .我还添加了一个 static_assert 以确保客户端不会不小心犯这个错误。 static_assert不是绝对必要的，因为无论如何你都会得到一个编译时错误。然而 static_assert可以提供更具可读性的错误消息。

但这不是解决问题的唯一方法。另一种方式，允许客户端实例化 parse使用左值引用类型，是部分特化解析:

template<class T>
class parse<T&>
{
public:
    // parse will modify a local copy or move of its input parameter
    void operator()(T const& arg, int n) const { /* optimized for lvalues */ }
};

现在客户端不需要做 decay舞蹈:

template<class T>
void split(T&& arg, int n)
{
    for (auto i = 0; i < n - 1; ++i)
        parse<T>()(arg , i);                 // copy n-1 times
    parse<T>()(std::forward<T>(arg), n - 1); // possibly move the n-th time
}

并且您可以在 parse<T&> 下应用特殊逻辑如有必要。

关于c++ - 多次传递输入参数的完美转发，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20195908/