Domanda su C++ 0x reference collapse

Question

Non so perché questo codice non possa essere compilato. Ho provato in Visual C++ 2010 e gcc con -std = C++ 0x. qualcuno ti da qualche suggerimento? grazie!

template<typename T> 
class Foo 
{ 
public: 
void test(const T&){cout<<"const";} 
void test(  T&){cout<<"non const";} 
}; 

int main() 
{ 
int a; 
Foo<int&> f; 
} 

errore di compilazione: 'vuoto Pippo :: test (T)': funzione membro già definito o dichiarata

ma perché questo può essere compilato?

template<typename T> void foo(const T&){cout<<"const"; } 
template<typename T> void foo(T&){cout<<"non const"; } 
int main() 
{ 
    int a; 
    foo<int&>(a); 
} 

i'v Leggi C++ 0x articolo diceva: T & & == T &, così const T & & == const T &?

Answer 1

Questo:

Foo<int&> f; 

dà origine a questa esemplificazione:

class Foo<int&> 
{ 
public: 
void test(int&); 
void test(int&); 
}; 

const applicato ad un tipo che è un riferimento è un no-op. Confronto con una funzione di membro non statico che operano su un membro di dati di riferimento:

struct A { 
    int &ref; 

    // valid: const member function doesn't treat "ref" as "const int&". 
    void operate() const { 
    ref = 0; 
    } 
}; 

Devi passare int a Foo<...> per raggiungere il tuo obiettivo.

Answer 2

i'v read c++0x article said: T& & ==T& , so const T& & == const T& ?

In realtà, questo non ha molto senso. IMHO, è meglio mettere questo in una tabella:

T  T&  const T  const T& 
--------------------------------------- 
int  int& const int const int& 
int& int& int&   int& 
     (1)  (2)   (1+2) 

1: Reference collapsing in action 
2: const applies to the reference and is therefore ignored 

Se T è già un riferimento (2a fila) const in const T applica al riferimento e non con l'arbitro. Ma un riferimento è intrinsecamente costante nel senso che non è possibile fare riferimento ad un altro oggetto dopo l'inizializzazione, quindi un const viene semplicemente ignorato qui. Puoi pensarlo come "const crollare". ;-)

Answer 3

Per la seconda domanda, le due funzioni istanziate hanno lo stesso tipo di parametro, ed entrambi sono modelli (se uno è un modello, l'altro è una funzione non modello, la risoluzione di sovraccarico sceglierà quella successiva), quindi la risoluzione di sovraccarico sceglierà il modello più specializzato. Generalmente const T & è un tipo più specializzato di T &, quindi viene chiamata la prima funzione di modello.