Question

请考虑以下代码：

#include <iostream>
#include <tuple>
#include <utility>

// A.
template <typename... Args>
void f (const char* msg, Args&&... args)
{
    std::cout << "A. " << msg << "\n";
}

// B.
template <typename... Args>
void f (const char* msg, std::tuple<Args...>&& t)
{
    std::cout << "B. " << msg << "\n";
}

struct boo
{
    const std::tuple<int, int, long> g () const
    {
        return std::make_tuple(2, 4, 12345);
    }
};

int main ()
{
    f("First", 2, 5, 12345);
    f("Second", std::make_tuple(2, 5, 12345));

    boo the_boo;
    f("Third", the_boo.g());
    f("Fourth", std::forward<decltype(std::declval<boo>().g())>(the_boo.g()));

    return 0;
}

输出结果为：

A. First
B. Second
A. Third
A. Fourth

从输出中可以看出它没有做我想做的事情，那就是我希望 Third 和 Fourth 来完成 B.。版本的功能。来自 Fourth 调用的 std :: forward 是多余的，因为那里不会发生完美转发。为了获得完美的转发，我知道：

我必须在类型推导上下文中使用右值引用
参数的类型必须是函数的模板类型

我明白它不起作用。但我没有完全掌握：

为什么通过使用 std :: tuple 来改变上下文，使其无法按预期工作？为什么模板参数不能是类型另一个模板类型？
我怎样才能（优雅地）修复它？

Answer 1

你的问题是，在第三和第四，你传递了一个const std::tuple，其中B.期望一个非const版本。

当编译器尝试为f调用生成代码时，它会看到您使用const std::tuple进行调用，因此将Args...的类型推断为const std::tuple }。调用B.无效，因为该变量具有与预期不同的const限定条件。

要解决此问题，只需使g()返回非const元组。

修改

为了完美转发，您需要一个推断的上下文，正如您在问题中所说的那样。当您在函数参数列表中说std::tuple<Args...>&&时，会推导出Args...，但std::tuple<Args...>&&不是;它只能通过右值引用。为了解决这个问题，该参数必须采用T&&形式，其中T是推导出来的。

我们可以使用自定义类型特征来完成此任务：

template <typename T> struct is_tuple : std::false_type {}; template <typename... Args> struct is_tuple <std::tuple<Args...>> : std::true_type {};

然后我们使用此特征为仅元组启用单参数模板：

// B. template <typename T, typename = typename std::enable_if< is_tuple<typename std::decay<T>::type>::value >::type> void f (const char* msg, T&& t) { std::cout << "B. " << msg << "\n"; std::cout << "B. is lval == " << std::is_lvalue_reference<T>() << "\n"; }

或者：

//! Tests if T is a specialization of Template template <typename T, template <typename...> class Template> struct is_specialization_of : std::false_type {}; template <template <typename...> class Template, typename... Args> struct is_specialization_of<Template<Args...>, Template> : std::true_type {}; template <typename T> using is_tuple = is_specialization_of<T, std::tuple>;

is_specialization_of 取自here并由this question建议。

现在我们有完美的转发！

int main () { f("First", 2, 5, 12345); f("Second", std::make_tuple(2, 5, 12345)); boo the_boo; f("Third", the_boo.g()); f("Fourth", std::forward<decltype(std::declval<boo>().g())>(the_boo.g())); auto the_g = the_boo.g(); f("Fifth", the_g); return 0; }

输出：

A. First B. Second B. is lval == 0 B. Third B. is lval == 0 B. Fourth B. is lval == 0 B. Fifth B. is lval == 1

完美转发和std :: tuple

1 个答案: