🚀 go-pugleaf

Am 20. Nov. 1995 schrieb Roger Wegner (MERLEAU@merleau.prima.ruhr.de):

> Hallo allerseits,

> ich habe eine Frage bezüglich des friend-Konzepts in C++. Ich möchte eine Ele-
> mentfunktion einer Klasse B zum Freund einer Klasse A erklären. Klasse B  
> wird aber erst nach Klasse A definiert (mal angenommen, das ist wirklich  
> nicht zu ändern...).

Wenn eine bestimmte Elementfunktion von B zum Freund von A werden soll,
so muß in der Definition von A sowas wie

	friend B::f();

stehen. Das setzt voraus, daß B bereits definiert ist, da nur in der
Definition von B die Elementfunktion f deklariert werden kann. Das ganze
sähe dann etwa so aus:

	class A;

	class B {
	  public:
	    int f(A&);
	};

	class A {
	    int i;
	    friend int B::f(A&);
	};

	int B::f(A &a) { return a.i; }

Wenn es aus irgendeinem Grund nicht möglich ist, die Definition von B
vor die Definition von A zu schreiben, so bleibt leider keine andere
Möglichkeit als die ganze Klasse B zum Freund von A zu machen.


Karl-Heinz Krause

Hallo,

Krause@btx.dtag.de (Karl-Heinz Krause) wrote:
>> ich habe eine Frage bezüglich des friend-Konzepts in C++. Ich möchte eine Ele-
>> mentfunktion einer Klasse B zum Freund einer Klasse A erklären. Klasse B  
>> wird aber erst nach Klasse A definiert (mal angenommen, das ist wirklich  
>> nicht zu ändern...).
>
>Wenn eine bestimmte Elementfunktion von B zum Freund von A werden soll,
>so muß in der Definition von A sowas wie

	friend B::f();

>stehen. Das setzt voraus, daß B bereits definiert ist, da nur in der
>Definition von B die Elementfunktion f deklariert werden kann. Das ganze
>sähe dann etwa so aus:

	class A;

	class B_0 {
	  public:
	    virtual int f(A&);
	};

	class A {
	    int i;
	    friend int B_0::f(A&);
	};


        class B : public B_0 {
           ...
        };  
	
 int B::f(A &a) { return a.i; }

>Wenn es aus irgendeinem Grund nicht möglich ist, die Definition von B
>vor die Definition von A zu schreiben, so bleibt leider keine andere
>Möglichkeit als die ganze Klasse B zum Freund von A zu machen.

Es gibt noch die Moeglichkeit eine Hilfsklasse (hier B_0) vor A zu 
deklarieren, die genau die benoetigten Funktionen von B beinhaltet,
eventuell als virtual. Diese Klasse oder die Funktionen koennen dann
in A als friends deklariert werden. Die spaeter deklarierte Klasse B
wird einfach von der Hilfsklasse B_0 abgeleitet. 


-- 
===============================================================================
                       knut@studbox.uni-stuttgart.de
===============================================================================

In article <48vc2m$uvk@info4.rus.uni-stuttgart.de>
from 22 Nov 1995 14:28:38 GMT
Knut <Knut@studbox.uni-stuttgart.de> wrote:

>[...]

Zusatzfrage: werden Freundschaften weitervererbt ?

Raphael

+-------------------------------------------------------------------+
| Raphael Posmyk (Hamburg, Germany)                                 |
| "... carpe diem, quam minimum credula postero..." (Horatius)      |
| Please send/reply all to raphael.posmyk@hamburg.netsurf.de        |
+-------------------------------------------------------------------+

MERLEAU@merleau.prima.ruhr.de (Roger Wegner) wrote:

>Hallo allerseits,

>ich habe eine Frage bezüglich des friend-Konzepts in C++. Ich möchte eine Ele-
>mentfunktion einer Klasse B zum Freund einer Klasse A erklären. Klasse B  
>wird aber erst nach Klasse A definiert (mal angenommen, das ist wirklich  
>nicht zu ändern...).

>Es soll vermieden werden, daß die gesamte Klasse B zum Freund von A wird. Eine
>Vorausdeklaration der Elementfunktion wird nicht akzeptiert, da dabei ja  
>schon vom Typ B gebraucht gemacht wird.

>Vorausgesetzt, ich habe da nichts mißverstanden, behauptet Lippman in
>"C++, Einführung und Leitfaden" (2. dt. Ausgabe, S. 265 unten), daß die  
>gesamte Klasse B zum Freund von A werden muß. Das kann doch nicht sein,  
>oder?

Interessante Frage. Ich nehme an, daß in etwa folgendes gemeint ist:

class B;

class A  {

  friend void B::foo();

  };

mit nachfolgender Definition von B. 
Die friend-Deklaration ist IMHO nicht möglich, da foo kein Mitglied
von B ist (den Informationsstand des Compilers vorausgesetzt). 
Dies als Fehler zu betrachten ist außerdem sinnvoll, denn was sollte
man von der - dann auch legalen - Konstruktion 

class B;

class A  {

  friend void B::foo() { cout << "hello" << endl; }

  };

halten? Soll man nun etwa

  B b;
  b.foo();

schreiben können? Sicher NICHT! Denn die Mitglieder, die eine Klasse
enthält, sollten ausschließlich in der Klassendefinition stehen. Man
stelle sich vor, wie man (d.h. ein Compiler oder ein Entwickler) sonst
die Mitglieder einer Klasse feststellen könnte - vielleicht befindet
sich A in einem anderen Modul? Es gibt Programme mit mehr als 100
Modulen.....

Es ist also klar, daß B vollständig vor A zu definieren ist. Nun kommt
wieder das alte Problem: A braucht B und B braucht A... 
DIES IST EIN DESIGN-Fehler! Vielleicht postest Du Deinen jetzigen
Ansatz etwas ausführlicher, und wir werden sehen, was man machen kann.



So long...





------------------------------------------------
Martin Aupperle
100754.2730@compuserve.com
OOA,OOD,OOP with C++, courses,trainig,coaching,C++-books
resources available. email for info
------------------------------------------------