¿Qué es std :: decay y cuándo debe usarse?

¿Cuáles son las razones de la existencia de std::decay? ¿En qué situaciones es std::decayútil?

_{<joke> Obviamente se usa para descomponer los std::atomictipos radiactivos en no radiactivos. </joke>}

N2609 es el documento que propuso std::decay. El artículo explica:

En pocas palabras, decay<T>::typees la transformación del tipo de identidad, excepto si T es un tipo de matriz o una referencia a un tipo de función. En esos casos, se decay<T>::typeobtiene un puntero o un puntero a una función, respectivamente.

El ejemplo motivador es 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); 
}

que aceptó sus parámetros por valor para hacer que los literales de cadena funcionen:

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

Si aceptó sus parámetros por referencia, T1se deducirá como un tipo de matriz, y luego la construcción de un pair<T1, T2>estará mal formada.

Pero obviamente esto conduce a ineficiencias significativas. De ahí la necesidad de decayaplicar el conjunto de transformaciones que ocurre cuando ocurre el paso por valor, lo que le permite obtener la eficiencia de tomar los parámetros por referencia, pero aún obtener las transformaciones de tipo necesarias para que su código funcione con literales de cadena, tipos de matriz, tipos de funciones y similares:

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)); 
}

Nota: esta no es la make_pairimplementación real de C ++ 11 : el C ++ 11 make_pairtambién desenvuelve std::reference_wrappers.

Cuando se trata de funciones de plantilla que toman parámetros de un tipo de plantilla, a menudo tiene parámetros universales. Los parámetros universales son casi siempre referencias de un tipo u otro. También están calificados con volatilidad constante. Como tal, la mayoría de los rasgos tipográficos no funcionan en ellos como cabría esperar:

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

La solución aquí es usar 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