在处理接受模板类型形参的模板函数时，通常使用通用形参。通用形参几乎总是这样或那样的引用。它们也是const-volatile限定的。因此，大多数类型的特征并不像你想象的那样对他们起作用:

template<class T>
void func(T&& param) {
    if (std::is_same<T,int>::value) 
        std::cout << "param is an int\n";
    else 
        std::cout << "param is not an int\n";
}

int main() {
    int three = 3;
    func(three);  //prints "param is not an int"!!!!
}

http://coliru.stacked-crooked.com/a/24476e60bd906bed

这里的解决方案是使用std::decay:

template<class T>
void func(T&& param) {
    if (std::is_same<typename std::decay<T>::type,int>::value) 
        std::cout << "param is an int\n";
    else 
        std::cout << "param is not an int\n";
}

http://coliru.stacked-crooked.com/a/8cbd0119a28a18bd

<joke>它显然是用来将放射性std::原子类型衰变为非放射性的

N2609是提出std::decay的论文。论文解释道:

简单地说，衰减<T>::type是单位类型转换除 如果T是数组类型或函数类型的引用。在那些 case衰变<T>::type产生一个指针或指向函数的指针， 分别。

激励的例子是c++ 03 std::make_pair:

template <class T1, class T2> 
inline pair<T1,T2> make_pair(T1 x, T2 y)
{ 
    return pair<T1,T2>(x, y); 
}

它接受其参数值，使字符串字面量工作:

std::pair<std::string, int> p = make_pair("foo", 0);

如果它通过引用接受其参数，则T1将被推导为数组类型，然后构造一个<T1, T2>的对将是病态的。

但这显然会导致显著的低效率。因此需要衰减，应用值传递发生时发生的转换集，允许你通过引用获得参数的效率，但仍然获得你的代码所需的类型转换，以处理字符串字面量，数组类型，函数类型等:

template <class T1, class T2> 
inline pair< typename decay<T1>::type, typename decay<T2>::type > 
make_pair(T1&& x, T2&& y)
{ 
    return pair< typename decay<T1>::type, 
                 typename decay<T2>::type >(std::forward<T1>(x), 
                                            std::forward<T2>(y)); 
}

注意:这不是c++ 11 make_pair的实际实现——c++ 11 make_pair还会解包std::reference_wrappers。