Newsgroup: it.comp.lang.c++
Titolo: Forward declaration di classi annidate

Ho una classe che contiene la dichiarazione di una sottoclasse, ad es:
struct A {
      .....
      struct Inner { ...}
};
E` possibile specificare una forward declaration per la classe Inner ?
Io utilizzo g++-3.4, ed ho provato senza successo con le seguenti 
dichiarazioni:
class A;          // OK
class A::Inner;   // Error expecting typename
Esiste una soluzione ?

 Esiste una soluzione ?
C'e` una risposta simile qui (il link è su due righe attenzione):
http://groups.google.it/groups?hl=it&lr=&selm=sYImc.6703%24CP6.532%40
tornado.fastwebnet.it
-- 
alef


Grazie alef ma in questo caso non vedo un problema di ricorsione o di 
forward declaration per enumerativi (nel mio esempio Inner e` un tipo). 
Chiarisco meglio l'esempio
class A;          // OK
class A::Inner;   // Questo il compilatore g++-3.4 non lo accetta.
                   // restituisce "Error expecting typename"
struct B {
    A& Ref();         // 1) questo funziona
    A::Inner& Ref2(); // 2) questo non funziona
};
Come vedi non c'e` ricorsione, e mi stupisce che funzionando 1) non sia 
possibile far funzionare 2)

 possibile far funzionare 2)
Sospetto che l'ultimo puoi farlo solo se lo fai dentro class A;
Saluti
-- 
alef

 Esiste una soluzione ?
class A {
    public:
    class Inner{
        /* ... */
    };
};
class B{
    public:
        A a;
        A::Inner I;
};
A me questo codice lo compila (chiaramente, visto che ha accesso alla
definizione di A).
Tuttavia io immagino che tu voglia fare una cosa del tipo
class C{
public:
	class A;
	class A::Inner;
	A::Inner *p;
}
senza includere nulla riguardo al primo file.
Afaik le forward declaration dicono semplicemente "guarda che questo qui
e` un tipo vero, non e` un errore mio, ed e` definito altrove".
Lui non ha bisogno di sapere nient'altro (e infatti lo usi con un
puntatore).
http://www-subatech.in2p3.fr/~photons/subatech/soft/carnac/CPP-INC-1.shtml
Invece in questo caso tu per potere scrivere A::Inner non ti basta sapere
che A e` un tipo e che Inner e` pure un tipo dentro A.
Avresti bisogno di avere informazioni su A.
Penso che potresti *non* avere informazioni su Inner, ma di A ne hai
bisogno.
Invece funziona
/* file1.hh */
class Inner{
  /* ... */
};
/* file2.hh */
class A{
  public:
    class Inner;
};
/* file2.cc */
#include "file2.hh"
class C{
  public:
    class A::Inner;
};
-- 
RiK0
[ non credo negli schemi non vincenti ]
[     two is an odd prime number.     ]

 Avresti bisogno di avere informazioni su A.
Qui intendevo dire che hai bisogno di sapere che Inner e` dentro A, quindi
devi conoscere A. Sorry...
Mi e` venuto anche un altro metodo, ma non lo ho provato.
class C{
  class Inner;
};
e poi dove definisci A, fuori provi a mettere un using A::Inner; ma allora
tanto vale dichiararlo fuori...
(insisto pero`, qui non ho provato).


 
Grazie Enrico
Si quello di cui avevo bisogno era poter dire Inner e` un tipo dentro A
senza dare visibiita` di A.
Cercando nel Web "forward declaration of nested class" ho trovato
esattamente questa richiesta su comp.lang.c++.moderated, e purtroppo la 
risposta era che non si puo` fare perche` il C++ vieta di riferirsi a 
membri di una classe se la definizione della classe non e` visibile!!