在Scott Meyers上文提到的文章(link)中,有经验说明：

If a variable or parameter is declared to have type T&& for some deduced type T,that variable or parameter is a universal reference.

实施例1

实际上,使用clang,我们看到以下代码片段将使用-std = c 14成功编译：

#include <utility>

template <typename T>
decltype(auto) f(T && t)
{
    return std::forward<T>(t);
}

int        x1 = 1;
int const  x2 = 1;
int&       x3 = x1;
int const& x4 = x2;

// all calls to `f` result in a successful
// binding of T&& to the required types
auto r1 = f (x1);    // varIoUs lvalues okay,as expected
auto r2 = f (x2);    // ...
auto r3 = f (x3);
auto r4 = f (x4);
auto r5 = f (int()); // rvalues okay,as expected

给出任何关于通用引用(转发参考)和类型扣除的描述(参见例如this explanation),这是很清楚的,为什么上述工作.虽然从同样的解释来看,为什么下面的工作也不尽如人意,

(失败)示例2

This question解决了同样的问题.然而,提供的答案不能解释为什么模板类型不被归类为“推导”.

我将要展示的(貌似)满足Meyers上述的要求.但是,以下代码剪切无法编译,产生错误(其中每个调用f)：

test.cpp:23:11: error: no matching function for call to ‘f’

auto r1 = f (x1);

test.cpp:5:16: note: candidate function [with T = foo,A = int] not
viable: no known conversion from ‘struct foo< int >’ to ‘foo< int > &&’
for 1st argument

decltype(auto) f (T< A > && t)

#include <utility>

//
// It **seems** that the templated type T<A> should
// behave the same as an bare type T with respect to
// universal references,but this is not the case.
//
template <template <typename> typename T,typename A>
decltype(auto) f (T<A> && t)
{
    return std::forward<T<A>> (t);
}

template <typename A>
struct foo
{
    A bar;
};

struct foo<int>        x1 { .bar = 1 };
struct foo<int> const  x2 { .bar = 1 };
struct foo<int> &      x3 = x1;
struct foo<int> const& x4 = x2;

// all calls to `f` **fail** to compile due
// to **unsuccessful** binding of T&& to the required types
auto r1 = f (x1);
auto r2 = f (x2);
auto r3 = f (x3);
auto r4 = f (x4);
auto r5 = f (foo<int> {1}); // only rvalue works

在上下文中,由于类型T A推论出f的参数,确定参数声明T A&& t将作为通用参考(正向参考).

示例3(为了清楚描述现有问题)

让我强调以下内容：示例2中的代码的失败不是由于struct foo<>是模板类型.失败似乎只是通过将f的参数声明为模板类型.

考虑以下代码的修改,现在编译：

#include <utility>

//
// If we re-declare `f` as before,where `T` is no longer a
// templated type parameter,our code works once more.
//
template <typename T>
decltype(auto) f (T && t)
{
    return std::forward<T> (t);
}

//
// Notice,`struct foo<>` is **still** a templated type.
//
template <typename A>
struct foo
{
    A bar;
};

struct foo<int>        x1 { .bar = 1 };
struct foo<int> const  x2 { .bar = 1 };
struct foo<int> &      x3 = x1;
struct foo<int> const& x4 = x2;

// all calls to `f` (again) result in
// a successful binding of T&& to the required types
auto r1 = f (x1);
auto r2 = f (x2);
auto r3 = f (x3);
auto r4 = f (x4);

令我惊讶的是,这个简单的改变完全改变了模板函数f的类型参数的类型扣除的行为.

问题：

为什么第二个例子不按预期工作？有没有技术来克服这个问题与模板类型在c 11/14？有没有众所周知的,现有的代码库(在野外)成功地使用c的向前引用模板类型？