假设有一个接收universal references的模板函数foo，定义如下：
template<typename T>
void foo(T&& t)
{
cout << "foo(T&& t)" << endl;
}
如果想对某些类型做特殊处理，写一个重载版本的foo，比如想对float类型做特殊处理，就写一个接收float类型的foo：
void foo(float n)
{
cout << "foo(float n)" << endl;
}
这样，如果我们写下 foo(1.0) 时，理论上应该输出"foo(float n)"，而实际上输出结果为"foo(T&& t)"。为什么呢？因为“Functions taking universal reference are the greediest functions in C++”，也就是说universal reference的函数能准确匹配几乎所有的类型。当我们调用foo(1.0)时，1.0被推导为double类型，如果调用foo(float n)，就需要做narrow conversion，所以编译器会认为foo(T&& t)为更准确的匹配，除非我们写下foo(1.f)时，才会调用foo(float)。只有在类型完全准确匹配时，才会调用重载版本，否则编译器会始终认为universal reference版本为准确匹配。
这个问题在类继承中会更为隐晦，假设有一个名为Base的class，Base有一个接收universal reference的模板构造函数，定义如下：
class Base
{
public:
template<typename T>
explicit Base(T&& t)
{
cout << "Base(T&& t)" << endl;
} Base(const Base& b)
{
cout << "Base(const Base& b)" << endl;
} Base(Base&& b)
{
cout << "Base(Base&& b)" << endl;
} Base() = default;
};
然后Derived继承Base：
class Derived : public Base
{
public:
Derived() = default; Derived(const Derived& d)
:Base(d)
{
} Derived(Derived&& d)
:Base(std::move(d))
{
}
};
这时候，如果我们写：
Derived a;
Derived b(a);
Derived c(std::move(a));
那么输出结果始终为“Base(T&& t)”，也就是在Derived的拷贝构造和移动构造中，Base的函数调用都是Base(T&& t)。因为传给Base的类型为Derived，所以编译器始终认为universal reference为准确匹配。
由于universal reference的匹配过于"strong"，一般都要避免重载，否则很容易出现匹配结果和预期不一致的情况。
如果无法避免重载呢？有两种方法：
1.使用type tags
考虑之前的foo函数，我们不重载foo函数，而是编写两个重载的fooImpl，fooImpl一个接受universal reference，一个接受float，两个函数用type tag参数来区分：
template<typename T>
void fooImpl(T&& t, std::false_type)
{
cout << "fooImpl(T&& t)" << endl;
} void fooImpl(float t, std::true_type)
{
cout << "fooImpl(float t)" << endl;
}
参数的type tag表示是否为浮点类型，那么foo就可以这么调用：
template<typename T>
void foo(T&& t)
{
fooImpl(std::forward<T>(t), std::is_floating_point<std::remove_reference_t<T>>());
}
这样有了type tag，只要参数是浮点类型，都会调用float版本的fooImpl。
2. 使用enable_if约束universal reference
如果某些情况我们不想使用universal reference版本，那么可以使用enable_if把它在重载决议的候选函数中屏蔽掉（SFINAE机制）。
对于foo函数，改写为：
template<typename T, typename = std::enable_if_t<
!std::is_floating_point<
std::remove_reference_t<T>
>::value>
>
void foo(T&& t)
{
cout << "foo(T&& t)" << endl;
} void foo(float t)
{
cout << "foo(float t)" << endl;
}
这样，如果参数为浮点类型，foo(T&& t)会被屏蔽掉，就会调用float版本的foo，这就和预期结果一致。
对于之前的Base class，思路也是一样的。用enable_if改写之前的代码：
class Base
{
public:
template<typename T, typename = std::enable_if_t<
!std::is_base_of <Base, std::decay_t<T>>::value
>>
explicit Base(T&& t)
{
cout << "Base(T&& t)" << endl;
} Base(const Base& b)
{
cout << "Base(const Base& b)" << endl;
} Base(Base&& b)
{
cout << "Base(Base&& b)" << endl;
} Base() = default;
};
这样，Derived的拷贝构造和移动构造就能正确调用到Base的函数（std::decay去掉references和cv-qualifiers）。
结论：
1. 尽量避免重载universal references模板函数。
2. 如果无法避免，使用type tags或者enable_if来编写重载函数。