Quando dovrei usare remove_reference e add_reference?

Question

Sto guardando unique_ptr [di VC10] e fare un paio di cose che non capisco:

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

Non sarebbe solo la scrittura _Dx & o _Ty & essere la stessa cosa?

Io in realtà capisco perché lo hanno fatto qui però:

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

Answer 1

get_deleter

Ogni riferimento viene rimosso dal tipo di ritorno, poi si aggiunge un riferimento. In C++ 11 conforme, l'aggiunta di uno & a uno esistente & (o &&) produce uno &. In C++ 03, tuttavia, ciò costituirebbe un riferimento al tipo di riferimento, che era illegale. Probabilmente MSVC sta usando le vecchie regole, o quel codice è stato scritto quando lo ha fatto e rimane perché è innocuo.

costruttore

Qui rimuovere il riferimento, aggiungere const, e quindi aggiungere il riferimento di nuovo, per essere passando per const riferimento. Questo perché aggiungere const direttamente a un tipo di riferimento è nulla! (§8.3.2/1) In C++ 11 o C++ 03, la dichiarazione dei parametri sarebbe valida ma non aggiungerebbe uno const, se il riferimento non fosse stato rimosso e sostituito.

operator*

Questo è essenzialmente lo stesso come get_deleter, ma sono andati su di esso un modo diverso, e _Ty non può essere un tipo di riferimento per cominciare. Mi sembra come se _Ty& fosse sufficiente, ma è una loro prerogativa.

Answer 2

Ecco un esempio, forse archetipo, per questo che abbiamo bisogno remove_reference, nella realizzazione di std::move: L'obiettivo è quello di restituire un tipo rvalue riferimento, sulla base del dedotto tipo di argomento della funzione.

Esempio: Foo x; move(x); Qui il numero move(x) deve restituire un tipo Foo&&. Ma l'argomento di move è un'espressione di tipo Foo&. Quindi, come può la funzione move dedurre il tipo giusto?

Il primo tentativo è quello di utilizzare ordinaria deduzione modello argomento e utilizzare un cast:

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

Ma cosa deve andare in ???? Se diciamo T x, allora T sarà dedotto come Foo&; se diciamo T & x, quindi T = Foo, e se diciamo T && x, non corrisponderà affatto. La seconda versione, T & x, sembra essere utile.

Ma allora la funzione non funziona su rvalues ​​per cominciare (es move(Foo(...)). In questo caso, vogliamo T && x modo che T = Foo e T&& = Foo&& lo desideri. Potremmo avere due overload, ma avendo più sovraccarichi è indesiderabile perché aumenta la complessità inutilmente.Infine, se qualcuno specificasse esplicitamente il modello paramete come move<Foo&>(x), la funzione sarebbe mai, perché quando T = Foo&, quindi T&& = Foo&.

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

Prima di tutto, il nuovo riferimento collasso regole implicano che T è deduce come sia Foo& o Foo&& nei due casi. Quindi, remove_reference elimina il riferimento e restituisce il tipo Foo in qualsiasi caso e l'aggiunta di && rende il tipo di ritorno Foo&& desiderato.

In un riassunto semplificato: è necessario remove_reference perché (Foo&)&& è Foo& e non Foo&&. Se si scrive codice modello che richiede il tipo base di un parametro modello che può essere dedotto come U& o U&&, è possibile utilizzare questo modello.

Answer 3

template class add_reference ha specializzazione per void, const void e const volatile void causa riferimento void type (void&) non è consentito. Se viene utilizzato _Ty&, verrà generato un errore di compilazione quando _Ty = void.