¿Es este código válido de C++?

Question

tuve el siguiente código, que era básicamente,

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

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

me había agregado por error un foo extra :: delante de la definición de foo :: método. Este código se compiló sin previo aviso con g ++ (ver 4.2.3), pero se borró usando Visual Studio 2005. No tenía un espacio de nombre llamado foo.

¿Qué compilador es el correcto?

Answer 1

Si leo correctamente el estándar, g ++ es correcto y VS es incorrecto.

ISO-IEC 14882-2003 (E), §9.2 clases (pag.153): Una clase-nombre se inserta en el ámbito en el que se declara inmediatamente después se ve el nombre de la clase. El nombre de clase también se inserta en el alcance de la clase en sí; esto se conoce como el nombre de clase inyectado. A los efectos de la verificación de acceso, el nombre de la clase inyectada se trata como si fuera un nombre de miembro público.

Tras los comentarios de abajo, también es particularmente útil para retener el siguiente relativa a las normas actuales de búsqueda de nombres:

ISO-IEC 14882 hasta 2.003 (E), §3.4-3 búsqueda de nombres (pag. 29): El nombre de la clase inyectada de una clase (cláusula 9) también se considera miembro de esa clase a los fines del ocultamiento de nombres y la búsqueda.

Sería extraño si no lo fuera, dada la parte final del texto en 9.2. Pero como comentó litb, esto nos asegura que, de hecho, g ++ está haciendo una interpretación correcta del estándar. No quedan preguntas.

Answer 2

¿Hay un espacio de nombres foo en algún otro módulo que incluya (y usted simplemente lo ignoraba)? De lo contrario, no es correcto. No estoy seguro de por qué g ++ permitió esto.

Answer 3

Comeau online acepta sin ningún hickups, por lo que es ya sea válida o el segundo fallo en Como He encontrado en casi diez años.

Answer 4

Krugar tiene la respuesta correcta aquí. El nombre que se encuentra cada vez es el nombre de la clase inyectada.

El siguiente es un ejemplo que muestra al menos una razón por la que el compilador añade el nombre de clase inyectada:

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'. 

    } 
}; 

Sin nombre inyectada las reglas de búsqueda actuales se llegará a alcanzar el ámbito que contiene 'A' y encontraría ':: B' y no 'NS :: B'. Por lo tanto, necesitaríamos usar "NS :: B" en todas partes en A cuando quisiéramos referirnos a la clase base.

Otro lugar que inyectan nombres acostumbrarse están con plantillas, donde dentro de la plantilla de clase, el nombre inyectado proporciona una correspondencia entre el nombre de la plantilla y el 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>' 
    } 
};