È questo codice C++ valido?

Question

ho avuto il seguente codice, che era fondamentalmente,

class foo { 
    public: 
    void method(); 
}; 

void foo::foo::method() { } 

mi aveva accidentalmente aggiunto un extra :: foo di fronte alla definizione di foo :: metodo. Questo codice è stato compilato senza preavviso usando g ++ (ver 4.2.3), ma è stato errato utilizzando Visual Studio 2005. Non avevo uno spazio dei nomi chiamato foo.

Quale compilatore è corretto?

Answer 1

Se leggo correttamente lo standard, g ++ ha ragione e VS è sbagliato.

ISO-IEC 14.882-2003 (E), §9.2 Classes (pag.153): A-nome di classe viene inserita nel campo di applicazione in cui è dichiarato immediatamente dopo il nome classe è visto. Il nome della classe viene anche inserito nell'ambito della classe stessa; questo è noto come nome della classe iniettata. Ai fini del controllo dell'accesso, il nome della classe immessa viene trattato come se fosse un nome membro pubblico.

Seguendo sui commenti qui sotto, è anche particolarmente utile per mantenere il seguente relativo alle regole attuali nomi di ricerca:

ISO-IEC 14.882-2003 (E), §3.4-3 Nome Lookup (pag. 29): Anche il nome di classe immesso di una classe (clausola 9) è considerato un membro di quella classe ai fini dell'identificazione e della ricerca dei nomi.

Sarebbe strano se non lo fosse, data la parte finale del testo in 9.2. Ma come commentato, questo ci rassicura che in effetti g ++ sta interpretando correttamente lo standard. Non ci sono domande

Answer 2

C'è uno spazio dei nomi in qualche altro modulo che includi (e ne eri semplicemente ignorante)? Altrimenti, non è corretto. Non sono sicuro del perché g ++ abbia permesso questo.

Answer 3

Comeau online accetta senza alcun hickups, quindi è valido o il secondo bug in como che ho trovato in quasi dieci anni.

Answer 4

Krugar ha la risposta corretta qui. Il nome che viene trovato ogni volta è il nome della classe iniettata.

Il seguente è un esempio che mostra almeno una ragione per cui il compilatore aggiunge il nome della classe iniettata:

namespace NS 
{ 
    class B 
    { 
    // injected name B // #1 
    public: 
    void foo(); 
    }; 

    int i;    // #2 
} 

class B     // #3 
{ 
public: 
    void foo(); 
}; 


int i;     // #4 

class A :: NS::B 
{ 
public: 
    void bar() 
    { 
    ++i;   // Lookup for 'i' searches scope of 
        // 'A', then in base 'NS::B' and 
        // finally in '::'. Finds #4 

    B & b = *this; // Lookup for 'B' searches scope of 'A' 
        // then in base 'NS::B' and finds #1 
        // the injected name 'B'. 

    } 
}; 

Senza il nome iniettato regole di ricerca attuali raggiungerebbero alla fine l'ambito di inclusione di 'A' e trovere ':: B' e non 'NS :: B'. Dovremmo quindi utilizzare "NS :: B" ovunque in A quando volevamo fare riferimento alla classe base.

Un altro luogo che hanno iniettato nomi abituarsi sono con i modelli, in cui all'interno del modello di classe, il nome iniettato fornisce una mappatura tra il nome del modello e il tipo:

template <typename T> 
class A 
{ 
// First injected name 'A<T>' 
// Additional injected name 'A' maps to 'A<T>' 

public: 
    void foo() 
    { 
    // '::A' here is the template name 
    // 'A' is the type 'A<T>' 
    // 'A<T>' is also the type 'A<T>' 
    } 
};