Funktionsaufruf in C++

[Tim S. (169)]

Servus,

ich möchte Funktionen von einer Klasse X in einer Klasse Y aufrufen. Wie 
mache ich dies in C++

vielen Dank

[Nico S. (Gast)]

Entweder

Y::Funktion() wenns statisch ist oder eben:

Y my_y_instanz;
my_y_instanz.Funktion();

Ungenauer konntest du deine Frage aber nicht beschreiben, oder?

[Mark B. (markbrandis)]

Nico S. schrieb:
>oder eben:
>
> Y my_y_instanz;
> my_y_instanz.Funktion();

Oder eben auf dem Heap:

Y *my_y_instanz = new Y();
my_y_instanz->Funktion();

[Peter II (Gast)]

Mark Brandis schrieb:
> der eben auf dem Heap:
>
> Y *my_y_instanz = new Y();
> my_y_instanz->Funktion();

und schon hat man ein speicherloch

[Lochsucher (Gast)]

für dumme -> wo ist das Loch ?

[Peter II (Gast)]

Lochsucher schrieb:
> für dumme -> wo ist das Loch ?

my_y_instanz wird freigegeben. Es fehlt ein

delete my_y_instanz;

aber wenn jetzt noch Funktion() eine exception wirft müssen man


  Y *my_y_instanz = new Y();
try {
  my_y_instanz->Funktion();
) catch( Exception& ex ) {
   delete my_y_instanz;
   throw ex;
}

oder mit autoptr.

[Mark B. (markbrandis)]

Peter II schrieb:
> Es fehlt ein
>
> delete my_y_instanz;

Das steht im Destruktor der Klasse X ;-)

[(prx) A. K. (prx)]

Wie wärs ganz einfach damit?
   X().Funktion();
Die Instanz entsteht temporär und verschwindet auch postwendend wieder.

Obs viel Sinn ergibt? Aber dafür war in der Frage zu wenig Substanz.

[Klaus W. (mfgkw)]

Für die Hausaufgabe wirds reichen.

[Karl H. (kbuchegg)]

A. K. schrieb:

> Aber dafür war in der Frage zu wenig Substanz.

Yep.
Bissi sehr wenig.

Zusammenfassend kann man sagen:

* Eine Funktion einer 'Klasse' kann man nur dann aufrufen, wenn diese
  Funktion static ist. Denn dann ist dieses Funktion mit keinem
  Objekt verknüpft und ist im Grunde eine freistehende Funktion, die
  nur aus organisatorischen Gründen innerhalb der Klasse ist und von
  dessen Scope eingeschlossen wird.

* In allen anderen Fällen benötigt man ein 'Objekt' vom entsprechenden
  Typ, damit man dann für dieses Objekt die entsprechende Member
  Funktion aufrufen kann.
  Wie und wo man zu diesem Objekt kommt, dafür gibt es viele
  Möglichkeiten. Aber um die Tatsache, dass man ein Objekt braucht
  kommt man nicht herum. Ist ja auch logisch. Denn das Objekt selber
  ist es ja, welches einen Satz der Klassen-Membervariablen enthält
  mit denen dann die Funktion arbeiten soll.


Und genau das ist ja im Kern der ganze Witz in der objektorientierten 
Programmierung: Das man einen Funktionsaufruf als eine Art Befehl an ein 
Objekt auffasssen kann, etwas zu tun. Und dazu benötigt man 
notwendigerweise ein Objekt.

Das ist wie bei BMW. Die Klassenbeschreibung ist der Bauplan, nach dem 
ein Auto gebaut wird. Mit dem Gaspedal gibt man aber nicht dem Plan die 
Anweisung schneller zu werden, sondern da braucht man schon ein reales 
Auto (also ein Objekt, das nach dem Plan gebaut wurde), damit die Aktion 
Sinn macht. Und wenn man dann viele entsprechende Autos, aka Objekte, 
vor sich hat, dann muss man ganz gezielt einem davon sagen "schneller 
werden", also das Objekt direkt ansprechen. Man benötigt daher immer 2 
Angaben: Wer muss Was machen. Und genau das findet sich dann auch in 
C++ wieder, indem man für ein Objekt eine Memberfunktion aufruft:

    Object.MachWas();