Was ist std :: zerfall und wann sollte es verwendet werden?

Was sind die Gründe für die Existenz von std::decay? In welchen Situationen ist das std::decaysinnvoll?

_{<joke> Es wird offensichtlich verwendet, um radioaktive std::atomicTypen in nicht radioaktive zu zerlegen. </ witz>}

N2609 ist das vorgeschlagene Papier std::decay. Das Papier erklärt:

Einfach ausgedrückt decay<T>::typeist dies die Transformation des Identitätstyps, es sei denn, T ist ein Array-Typ oder eine Referenz auf einen Funktionstyp. In diesen Fällen decay<T>::typeergibt das einen Zeiger bzw. einen Zeiger auf eine Funktion.

Das motivierende Beispiel ist 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); 
}

die ihre Parameter nach Wert akzeptierte, damit String-Literale funktionieren:

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

Wenn es seine Parameter als Referenz akzeptiert hat, T1wird es als Array-Typ abgeleitet und anschließend a erstelltpair<T1, T2> schlecht geformt.

Dies führt jedoch offensichtlich zu erheblichen Ineffizienzen. Daher ist es erforderlich decay, den Satz von Transformationen anzuwenden, der beim Übergeben von Werten auftritt, damit Sie die Effizienz der Referenzübernahme der Parameter erhalten und dennoch die Typtransformationen erhalten, die für die Arbeit Ihres Codes mit Zeichenfolgenliteralen erforderlich sind. Array-Typen, Funktionstypen und dergleichen:

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

Hinweis: Dies ist nicht die eigentliche C ++ 11- make_pairImplementierung. C ++ 11 make_pairentpackt auch std::reference_wrappers.

Wenn Sie mit Vorlagenfunktionen arbeiten, die Parameter eines Vorlagentyps verwenden, haben Sie häufig universelle Parameter. Universelle Parameter sind fast immer Referenzen der einen oder anderen Art. Sie sind auch konstant flüchtig qualifiziert. Daher funktionieren die meisten Typmerkmale nicht wie erwartet:

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

Die Lösung hier ist zu verwenden 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