Question à propos de la réduction de la référence C++ 0x

Question

Je ne sais pas pourquoi ces codes ne peuvent pas être compilés. Je ai testé dans Visual C++ 2010 et gcc avec -std = C++ 0x. Quelqu'un a-t-il quelque suggestion? merci!

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

Erreur de compilation: 'vide Foo :: test (T)': fonction membre déjà défini ou déclaré

mais pourquoi cela peut être compilé?

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 lire C++ 0x article dit: T & & == T &, donc const T & & == const T &?

Answer 1

Ce:

Foo<int&> f; 

donne lieu à cette instanciation:

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

const appliqué à un type qui est une référence est un no-op. Comparer avec une fonction de membre non-statique fonctionnant sur un membre de données de référence:

struct A { 
    int &ref; 

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

Vous devez passer à intFoo<...> pour atteindre votre objectif.

Answer 2

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

En fait, cela n'a pas beaucoup de sens. À mon humble avis, il est préférable de mettre cela dans une table:

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 

Si T est déjà une référence (2ème ligne) const dans const T applique à la référence et non à l'arbitre. Mais une référence est intrinsèquement constante dans le sens où vous ne pouvez pas faire référence à un autre objet après l'initialisation, donc un const est simplement ignoré ici. Vous pouvez le voir comme "const effondrement". ;-)

Answer 3

Pour la deuxième question, les deux fonctions instanciées ont le même type de paramètre et les deux sont des gabarits (si l'un est un gabarit, l'autre est une fonction non gabarit, la résolution de surcharge choisira la suivante), la résolution de surcharge choisira le modèle qui est le plus spécialisé. En général, const & est un type plus spécialisé que T &, donc la première fonction de modèle est appelée.