Qu'est-ce que std :: decay et quand faut-il l'utiliser?

Question

Quelles sont les raisons de l'existence de std::decay? Dans quelles situations std::decay est-il utile?

Answer 1

_{<blague> Il est évidemment utilisé pour se désintégrer radioactif std::atomic types dans les non-radioactifs. </blague >}

N2609 est le papier qui a proposé std::decay. Le document explique:

Autrement dit, decay<T>::type est du type à transformation ayant une identité sauf si T est un type tableau ou une référence à un type de fonction. Dans les cas , le decay<T>::type donne respectivement un pointeur ou un pointeur sur une fonction, .

L'exemple motivant est 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); 
} 

qui a accepté ses paramètres par valeur pour faire des chaînes littérales travail:

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

Si elle a accepté ses paramètres par référence, alors T1 sera déduit comme un type de tableau, puis la construction d'un pair<T1, T2> sera mal formé. Mais, évidemment, cela conduit à des inefficacités significatives. D'où la nécessité de decay, d'appliquer l'ensemble des transformations qui se produisent lorsque la valeur de passe se produit, vous permettant d'obtenir l'efficacité de prendre les paramètres par référence, mais obtenez toujours les transformations de type nécessaires pour que votre code fonctionne avec des littéraux de chaîne , les types de tableaux, les types de fonctions et similaires:

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

Note: ce n'est pas réelle C++ 11 make_pair mise en œuvre - 11 C++ make_pair aussi unwraps std::reference_wrapper s.

Answer 2

Lorsque vous manipulez des fonctions de modèle qui prennent des paramètres d'un type de modèle, vous avez souvent des paramètres universels. Les paramètres universels sont presque toujours des références d'une sorte ou d'une autre. Ils sont également qualifiés de const-volatile. En tant que tel, la plupart des caractères de type ne fonctionnent pas sur eux comme on pouvait s'y attendre:

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 solution est ici pour utiliser 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