🚀 go-pugleaf

Am 29. Nov. 1995 schrieb Uwe Tantz
(c4037@rphc1.physik.uni-regensburg.de>):

> Gruess Euch,

> ich haette ein Problem zu forward-Deklarationen:
> Weiss jemand, ob es moeglich ist, *eingebettete* Klassen forward zu 
> deklarieren? Was mir dabei vorschwebt ist etwa folgendes:

> -- Header-File
> class A
> {
>   public:
>   class B;

>   // in der Deklaration von A werden nur B-Pointer und -Referenzen gebraucht
>   void foo(B &x); 
> };

> -- Implementation
> class A::B
> {
>   // ... usw.
> };

> void A::foo(B &x)
> {
>   // ... usw.
> }

> Dieses wird aber so von keinem mir bekannten Compiler geschluckt. Weiss 
> jemand, ob es dafuer einen Grund gibt? Ich faende dies eine sinnvolle 
> Konstruktion. Wenn man B im globalen Scope definiert, klappts ja auch.

Die Konstruktion ist nach dem neuesten C++-Standard zulässig. Sie wird
in "The Design and Evolution of C++" ausdrücklich erwähnt. Ältere
C++-Compiler können es aber noch nicht. (Bei Borland C++ V. 4.5 geht's)


Karl-Heinz Krause

Uwe Tantz (c4037@rphc1.physik.uni-regensburg.de) wrote:
>  Gruess Euch,

>  ich haette ein Problem zu forward-Deklarationen:
>  Weiss jemand, ob es moeglich ist, *eingebettete* Klassen forward zu 
>  deklarieren? Was mir dabei vorschwebt ist etwa folgendes:

>  -- Header-File
>  class A
>  {
>    public:
>    class B;

>    // in der Deklaration von A werden nur B-Pointer und -Referenzen gebraucht
>    void foo(B &x); 
>  };

>  -- Implementation
>  class A::B
>  {
>    // ... usw.
>  };

>  void A::foo(B &x)
>  {
>    // ... usw.
>  }

>  Dieses wird aber so von keinem mir bekannten Compiler geschluckt. Weiss 
>  jemand, ob es dafuer einen Grund gibt? Ich faende dies eine sinnvolle 
>  Konstruktion. Wenn man B im globalen Scope definiert, klappts ja auch.


Die Konstruktion ist nach dem Standard erlaubt. Die Compiler sind bloss
noch nicht so weit.

Gruss
	Bernd 

--
+----------------------------------+
|          Bernd Eggink            |
|    Rechenzentrum Uni Hamburg     |
| admin@rzaix13.rrz.uni-hamburg.de |
+----------------------------------+

Am 2. Dez. 1995 schrieb Martin Aupperle (100754.2730@compuserve.com):

> Ich habe leider auf die Schnelle etwas übersehen:

> >void A::foo(B &x)
> >{
> >  // ... usw.
> >}

> ist falsch (oder zumindest nicht ganz richtig - hängt vom Stand des
> Compilers ab). 
> In der Parameterliste befindet man sich noch NICHT im Scope von A.
> Typen müssen daher voll qualifiziert werden, d.h. für B muß es A::B
> heißen. 

Nein, das ist nicht falsch. Die Formalparameterliste einer
Memberfunktionsdefinition gehört sehr wohl zum Scope der Klasse. (Alles
andere wäre auch nicht sinnvoll.)

> Das Problem gab's mit Uralt-Compilern nicht, da dort geschachtelte
> Typen immer globalen Scope hatten - eine Qualifizierung war deshalb
> nicht notwendig. Warum allerdings BC 4.5 das Original ohne Warnung
> schluckt, bleibt unklar. 

Der Borland-Compiler verhält sich hier genau richtig.


Karl-Heinz Krause