C++ Forward Dichiarare classi nelle classi

Question

Il seguente semplice pezzo di codice venga compilato, anche se non capisco perché:

class C { 
    class B; 

    class A { 
     B getB() { return B(); } 
    }; 

    class B { 
    }; 
}; 

int main(int, char**) 
{ 
    return 0; 
} 

Se poi commentare la "class C" roba, in modo che la dichiarazione anticipata di B , la definizione di A e la definizione di B sono più annidati all'interno di una classe, il codice non viene compilato, poiché B è di un tipo incompleto:

main.cpp: In member function 'B A::getB()': 
main.cpp:6: error: return type 'struct B' is incomplete 
main.cpp:6: error: invalid use of incomplete type 'struct B' 
main.cpp:3: error: forward declaration of 'struct B' 

I underst e cosa significa per un tipo essere incompleto, vale a dire che non è stato ancora definito e quindi il compilatore non può forse sapere quanto spazio allocare per esso. Ma perché B non è considerato incompleto nel codice sopra, dove A e B sono entrambi dichiarati e definiti all'interno di C?

Answer 1

Credo che questo sia una conseguenza della [basic.scope.class]:

Il potenziale portata di un nome dichiarato in una classe consiste non solo della regione dichiarativa seguente punto di dichiarazione del nome , ma anche di tutti i corpi di funzione , argomenti predefiniti, specifiche di eccezione e iniziatori start-up o equivalenti di membri di dati non statici in tale classe (compresi tali elementi nelle classi nidificate ).

Cioè, la portata della dichiarazione piena del B comprende il corpo della funzione membro della classe nidificata:

class C { 
    class B; // (1) 

    class A { 
     B getB() { 
      return B(); // both (1) and (2) in scope here 
         // since (2) is the complete type declaration, 
         // this is perfectly fine 
     } 
    }; 

    class B { // (2) 
    }; 
}; 

In confronto, se C erano un namespace invece di una classe , l'ambito della dichiarazione completa della classe B non si estenderebbe allo A::getB(). L'unica dichiarazione visibile sarebbe la forward-declaration di B che ho etichettato come (1) - quindi B() sarebbe la costruzione di un tipo incompleto lì.

Answer 2

Lo standard prevede esplicitamente che il corpo del metodo venga interpretato dopo la classe che lo racchiude.

Pertanto, al momento della valutazione del corpo di C::A::getB(), A, B e C sono tutti i tipi completi.

Answer 3

Il corpo di una funzione membro inline non viene elaborato finché la definizione della classe non è stata completamente elaborata.

Quindi, è possibile utilizzare:

class A 
{ 
    class B; 
    B getB() { return B(); } 

    class B {}; 
}; 

che permette anche variabili membro che non sono ancora dichiarati per essere utilizzato in linea definizione di funzione membro.

class Foo 
{ 
    int getBar() { return bar; } 

    int bar; 
}; 

Sono indovinare la stessa logica è esteso all'inline definizioni delle funzioni membro delle classi nidificate - cioè esse non vengono elaborati fino alla definizione della classe di contenimento è completamente elaborata.

PS Non riesco a individuare rapidamente il riferimento nello standard che verificherebbe il mio reclamo.

PS 2The answer by Barry ha il riferimento nello standard che rende valido il codice nella domanda.

Answer 4

Oltre a questo, quando ho la necessità di trasmettere dichiarare classi nidificate tendo a sentire l'odore un po 'di cattiva progettazione nel mio codice, il trucco che uso è:

// Foo.h 
class Foo { 
    class Bar { 
    }; 
}; 
class Foobar : public Foo::Bar {}; 


// Zoo.h 
/* Fwd declare */ 
class FooBar;