Vereinbarungsfrage

[freakC++]

Hallo zusammen,
wenn ich eine Klasse erstellt habe, muss natürlich auch eine Instanz erstellt werden. Sonst wäre die Klasse nicht zu gebrauchen. Doch ist mir der Unterschied folgender Möglichkeiten nicht ganz klar.

Möglichkeit 1:

class TExample
{
 public:
 void __fastcall Ausgabe (void);
 __fastcall TExample ();
};

...

TExample *Example1;// Es wird mit dem Zeigeoperator gearbeitet

...

void __fastcall TForm1::FormCreate(TObject *Sender)
{
 Example1 = new TExample ();
}
//---------------------------------------------------------------------------
void __fastcall TExample::Ausgabe (void)
{
 Application->MessageBoxA("Hallo", "Guten Abend", 0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 Example1->Ausgabe(); //Eine Methode wird mit dem Zeigeoperator aufgerufen
}
//---------------------------------------------------------------------------

Möglichkeit 2:

class TExample
{
 public:
 void __fastcall Ausgabe (void);
 __fastcall TExample ();
};

...

TExample Example1; //Eine "einfache" Vereinbarung

... 
//---------------------------------------------------------------------------
__fastcall TExample::TExample ()
{
}
//---------------------------------------------------------------------------

void __fastcall TExample::Ausgabe (void)
{
 Application->MessageBoxA("Hallo", "Guten Abend", 0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 Example1.Ausgabe(); //Es wird mit dem Auswahloperator gearbeitet.
}

Bei der zweiten Möglichkeit fehlt die Zeile "Example1 = new TExample ();". Muss denn hier kein Speicherplatz festgelegt werden??

Wann verwende ich welche Möglichkeit, denn es kommt ja das gleiche dabei heraus. Ist das egal oder nicht?

Vielen Dank für eure Hilfe
lg, freakC++

[blub* 0]

Hi,

mit

TExample *Example1

erzeugst du erstmal nur einen Zeiger auf eine beliebige Instanz der TExample Klasse. Mit dem new Operator wird dann der entsprechende Speicher allokiert, die Klasse instanziert und der Zeiger so umgebogen dass er auf den entsprechende Speicherplatz zeigt.

TExample Example1

Damit erzeugst du direkt eine Instanz von TExample, du brauchst keinen new Operator.

Zum Thema wann du was verwendest, hier kommt es stark darauf an was deine Klasse machen soll. Ein anschauliches Beispiel fällt mir leider gerade nicht ein.

Achja, als Tipp: wenn solche Fragen hier noch offen sind:

Bei der zweiten Möglichkeit fehlt die Zeile "Example1 = new TExample ();". Muss denn hier kein Speicherplatz festgelegt werden??

dann schau dir doch erstmal nochmal was zum Thema Zeiger an und zwar mit allem drum und dran.

Gruss,

Max

#edit: Achso, der Unterschied zwischen "." und "->" ist einfach zu erklären. Mal ein Beispiel:

Example *example1;
Example example2;

example2.test();    // ist das

(*example1).test(); // gleiche
example1->test();   // ...

Der "->" Operator ist also nichts anderes als der Derefernzierungsoperator "*" mit darauffolgendem Zugriffsoperator (heißt der so?) ".".

Hoffe ich konnte dir helfen ;).

[akari]

Hallo

Der wichtige Unterschied zwischen

TExample *Example1; // A
TExample Example1;  // B

ist zunächst das A ein Zeiger ist, der auf eine Instanz von Example zeigt. Die Instanz ist aber nicht weiter mit dem Zeiger verbunden, existiert also unabhängig von dem Zeiger. Es ist sogar möglich den Zeiger auf keine gültige Instanz zeigen zu lassen oder die Instanz zu wechseln.
Die Variante B ist dagegen eine Variable, die direkt mit der Instanz verbunden ist. Die Instanz ist nur genauso lange gültig wie die Variable. Die Variable hat immer genau eine Instanz, und diese läßt sich nicht wecheln.

Die Anwendungszwecke ergeben sich dadurch : B wird für lokale Variablen verwenden, deren Gültigkeit fest eingegrenzt ist (z.B. durch eine Funktion oder eine Schleife). Die Instanz wird automatisch auf dem Stack angelegt, ein schneller aber auch sehr begrenzter Speicher.
A hingegen ermöglicht die Verwendung des Heaps, einen sehr viel größeren aber dafür auch langsameren Speichers. Besonders Arrays werden lieber gerne dynamisch auf dem Heap angelegt. Außerdem ermöglichen Zeiger die mehrfache Referenz auf eine einzelne Instanz, ohne diese zu kopieren.

bis bald
akari

[freakC++]

hi,
vielen Dank für eure Hilfe. Es ist nur so, dass ich bis jetzt nur Instantzen von meinen Klassen erstelle und da sehe ich irgendwie noch den unterschied noch nicht. Wahrscheinlich werde ich eure Aspekte erst dann richtig bemerken, wenn ich ein bisschen weiter bin und mehr weiß. Dennoch habt ihr mir sehr geholfen.

Vielen Dank
lg, freakC++