¿Cuándo debería usar remove_reference y add_reference?

Question

estoy mirando unique_ptr [de VC10] y hacer un par de cosas que no entiendo:

typedef typename tr1::remove_reference<_Dx>::type _Dx_noref; 

_Dx_noref& get_deleter() 
    { // return reference to deleter 
    return (_Mydel); 
    } 

unique_ptr(pointer _Ptr, 
    typename _If<tr1::is_reference<_Dx>::value, _Dx, 
     const typename tr1::remove_reference<_Dx>::type&>::_Type _Dt) 
    : _Mybase(_Ptr, _Dt) 
    { // construct with pointer and (maybe const) deleter& 
    } 

typename tr1::add_reference<_Ty>::type operator*() const 
    { // return reference to object 
    return (*this->_Myptr); 
    } 

No sería simplemente escribiendo _Dx & o _Ty & ser la misma cosa?

que realmente entienden por qué lo hicieron aquí, sin embargo:

unique_ptr(pointer _Ptr, typename tr1::remove_reference<_Dx>::type&& _Dt) 
    : _Mybase(_Ptr, _STD move(_Dt)) 
    { // construct by moving deleter 
    } 

Answer 1

get_deleter

Cualquier referencia se elimina del tipo de retorno, a continuación, una referencia se vuelve a añadir. En C++ 11 conformes, al agregar un & a un & existente (o &&) se produce un &. Sin embargo, en C++ 03, eso estaría formando una referencia al tipo de referencia, que era ilegal. Probablemente MSVC está usando las reglas anteriores, o ese código se escribió cuando lo hizo y permanece porque es inofensivo.

constructor

Aquí se eliminan las referencias, agregue const, y luego agregar la referencia hacia atrás, a ser pasando por const referencia. Esto es porque agregar const directamente a un tipo de referencia hace nada! (§8.3.2/1) En C++ 11 o C++ 03, la declaración del parámetro sería válida pero no agregaría un const, si la referencia no se eliminó y reemplazó.

operator*

Ésta es esencialmente la misma que get_deleter, pero fue sobre él de una manera diferente, y _Ty no puede ser un tipo de referencia para empezar. Me parece que _Ty& sería suficiente, pero es su prerrogativa.

Answer 2

He aquí un ejemplo, posiblemente arquetípica, por eso que necesitamos remove_reference, en la implementación de std::move: El objetivo es devolver un tipo rvalue referencia, basado en el deducido tipo de argumento de la función.

Ejemplo: Foo x; move(x); Aquí move(x) debe devolver un tipo Foo&&. Pero el argumento de move es una expresión del tipo Foo&. Entonces, ¿cómo puede la función move deducir el tipo correcto?

El primer intento es utilizar la deducción argumento de plantilla ordinaria y utilizar un reparto:

template <typename T> T && move(??? x) { return static_cast<T&&>(x); } 

Pero qué debe entrar ???? Si decimos T x, entonces T se deduce como Foo&; si decimos T & x, luego T = Foo, y si decimos T && x, no coincidirá en absoluto. La segunda versión, T & x, parece ser útil.

Pero entonces la función no funciona en rvalues, para empezar (por ejemplo move(Foo(...)). En este caso, queremos T && x modo que T = Foo y T&& = Foo&& lo deseas. Podríamos tener dos sobrecargas, pero tener múltiples sobrecargas no es deseable porque aumenta la complejidad innecesariamenteY finalmente, si alguien fuera a especificar el parámetro de la plantilla explícitamente como move<Foo&>(x), la función sería nunca funciona, porque cuando T = Foo&, entonces también.

Así que en viene remove_reference:

template <typename T> 
typename std::remove_reference<T>::type && move(T && x) 
{ 
    return static_cast<typename std::remove_reference<T>::type &&>(x); 
} 

En primer lugar, la nueva referencia colapso reglas implican que es T deduce como sea Foo& o Foo&& en los dos casos. Luego, remove_reference quita la referencia y proporciona el tipo Foo en cualquier caso, y al agregar && se obtiene el tipo de devolución Foo&& deseado.

En un resumen muy simplificado: necesitamos remove_reference porque (Foo&)&& es Foo& y no Foo&&. Si alguna vez escribe un código de plantilla que necesita el tipo de base de un parámetro de plantilla que podría deducirse como U& o U&&, puede usar este modelo.

Answer 3

template class add_reference tiene especialización para void, const void y const volatile void porque no está permitido referencia de void type (void&). Si se usa _Ty&, generaría un error de compilación cuando _Ty = void.