Co to jest std :: decay i kiedy powinno się go używać?

Question

Jakie są powody istnienia std::decay? W jakich sytuacjach przydatne jest std::decay?

Answer 1

_{< żart > Jest to oczywiście używane do rozpadu radioaktywnego std::atomic typów do nieradioaktywnych. </żart >}

N2609 jest papier, który zaproponował std::decay. Papier wyjaśnia:

Mówiąc najprościej, decay<T>::type jest tożsamość typu transformacja wyjątkiem jeśli T jest typem tablicą lub odwołaniem do rodzaju funkcji. W tych przypadkach , decay<T>::type daje odpowiednio wskaźnik lub wskaźnik do funkcji, .

motywującą przykładem jest 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); 
} 

który przyjął swoje parametry przez wartość, aby literały łańcuchowe działa:

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

Jeśli akceptowane swoje parametry przez odniesienie, następnie T1 zostanie wydedukowane jako typ tablicowy, a następnie skonstruowanie modelu pair<T1, T2> będzie źle sformułowane.

Ale oczywiście prowadzi to do znacznej nieefektywności. Stąd potrzeba decay, aby zastosować zestaw transformacji, który występuje, gdy występuje wartość pass-by-value, co pozwala uzyskać efektywność przyjmowania parametrów przez odniesienie, ale nadal uzyskać transformacje typu potrzebne do pracy kodu z literałami łańcuchowymi , typy macierzy, typy funkcyjne i podobne artykuły:

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

Uwaga: to nie jest rzeczywiste C++ 11 make_pair realizacja - C++ 11 make_pair rozpakowuje również std::reference_wrapper s.

Answer 2

W przypadku funkcji szablonu, które pobierają parametry typu szablonu, często mają uniwersalne parametry. Parametry uniwersalne są prawie zawsze referencjami tego samego rodzaju. Są także niezmiennie wykwalifikowani. Jako takie, większość cech typu nie działają na nich, jak można się spodziewać:

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

Rozwiązaniem tego problemu jest użycie 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