C++ - istanza modello con tipo di riferimento

Question

Ho sentito un po 'di problema riferimento-riferimento e risoluzione this. Non sono molto bravo con la terminologia del Comitato C++, ma capisco che l'annotazione "Spostati in DR" nel link significa che questa è l'interpretazione corrente che i compilatori conformi agli standard dovrebbero rispettare.

Ho questo codice di esempio che non riesco a capire:

template <typename T> 
struct C { 
    void f(T&) { } 
    void f(const T&) { } 
}; 

int main() { 
    C<int> x;  // OK 
    C<int&> y;  // compile error: f cannot be overloaded 
    C<const int&> z; // compile error: f cannot be overloaded 
} 

ho capito l'errore nel caso C<const int&>: usando le regole di DR # 106 otteniamo due metodi con la stessa firma f (const int &). Quello che non ottengo è il caso C<int&>: non dovrebbe generare esattamente lo stesso codice di C<int> (almeno secondo la risoluzione di Stroustrup)?

Answer 1

DR significa solo "Rapporto difetti" e, per quanto ne so, la risoluzione descritta non lo ha (ancora) raggiunto lo standard. Per questo motivo, credo che un'implementazione C++ 03 rigorosamente conforme non dovrebbe compilare questo codice perché sta formando un riferimento a un riferimento.

[Modifica] Ho appena trovato uno nice answer su questo problema.

Answer 2

interessante notare che quando compilo il codice (Visual C++ 10 espresso) ottengo gli errori, ma anche quando provo questo caso più semplice:

int main(int argc, char* argv[]) 
{ 
    C<int> x;  // OK 
    C<const int> x1; // error C2535: 'void C<T>::f(T &)' : member function 
        // already defined or declared 
    return 0; 
} 

sembra che l'arbitro ref-to-crollando definito nella Repubblica Dominicana hai menzionato significa che il riferimento a const diventa un semplice riferimento non const all'interno del modello. Il mio problema è che non capisco perché il secondo f non sia semplicemente ignorato.

Se cambio C in modo che la seconda f è const Qualificato, adesso compila:

template <typename T> 
struct C { 
    void f(T&) { } 
    void f(const T& t) const {} 
}; 

L'implicazione sembra essere che quando C viene creata un'istanza con const nulla (ref o no), i due I sovraccarichi di C::f sono semplicemente identici e comportano il rilevamento di duplicati in fase di compilazione.

Forse qualcuno più intelligente di me può decifrare la catena in modo più definitivo qui.

EDIT: Sulla riflessione, non è sorprendente qui che T = const int& risultati nelle f sovraccarichi essere identico istanziati come

void f(const int&) {} 

Questo è ciò che il compilatore mi sta dicendo:

#include "stdafx.h" 

template <typename T> 
struct C { 
    void f(T&) { } 
    void f(const T&) { } 
}; 

int main() { 
    C<const int&> z; // compile error: f cannot be overloaded 
    return 0; 
} 

dà questo errore:

1>test.cpp(6): error C2535: 'void C<T>::f(T)' : member function already 
    defined or declared 
1>   with 
1>   [ 
1>    T=const int & 
1>   ] 
1>   test.cpp(5) : see declaration of 'C<T>::f' 
1>   with 
1>   [ 
1>    T=const int & 
1>   ] 
1>   test.cpp(10) : see reference to class template instantiation 
       'C<T>' being compiled 
1>   with 
1>   [ 
1>    T=const int & 
1>   ] 

Non sono nemmeno convinto che questo abbia qualcosa a che fare con la DR.