Folgender Code aus einer MFC-Anwendung:

CMainFrame* pFrame = new CMainFrame;

So wie ich es kenne ist es doch die Syntax für die Erzeugung eines dynamischen Objekts? Aber der Ungarischen Notation nach, ist es ja ein Zeiger...
Also was ist das jetzt nun - Zeiger oder dynamisches Objekt?

Eine weitere Frage wäre der Sinn der Verwendung eines Zeigers. Mir ist unklar warum man Zeiger verwendet, wenn man auch so direkt auf Elementvariablen und -methoden zugreifen kann?

A-jage

Aber der Ungarischen Notation nach, ist es ja ein Zeiger

CMainFrame* m_iFrame = new CMainFrame;

und jetzt ist ein integer member!

c++ syntax hat mit ungarischer notation ungefähr gar nix zu tun was da getan wird, ist einen pointer auf CMainFrame zu deklarieren und zu initialisieren. kann man auch dynamisches objekt nennen.

Der Vorteil von Zeigern ist, dass man damit auf des Gleiche Objekt zeigen kann. Somit hab ich keine Kopie sondern beziehe mich exakt auf das Gleiche.
Beispiel Du hast von einem Objekt mehrere Elemente.
Nun brauchst Du aber oft einen Bezug zu einem bestimmten Element in einer anderen Klasse...

Oft ist es Sinnvoller Referenzen statt Zeiger zu benutzen, je nach Fall.

Beispiel Du hast von einem Objekt mehrere Elemente.
Nun brauchst Du aber oft einen Bezug zu einem bestimmten Element in einer anderen Klasse...

Ähm - könntest du das bitte näher erklären - mit einem CodeBeispiel? Ist glaub ich das was ich haben möchte...

A-jage

in der SpellList sind alle Spells, die es gibt. Nun hat ein Spieler den Spell "A" in seinem "Zauberbuch", der Spell A belegt aber nicht 2 mal Speicher, sondern nur einmal. Wenn es nun noch mehr Spieler gebene würde, die die gleichen Spells besitzen hättest Du ohne Zeiger jeden Spell mehrmals als Kopie.

Oder Beispiel Risiko. Ein Spieler kann mehrere Länder besitzen.
Also gibt es je Land einen Zeiger auf einen Spieler, der dieses Land gerade Besitzt. Wenn das Land "befreit wird", dann änder ich den Zeiger auf den neuen Spieler und gut ist.

Aber...

Beispiel:

class CKlasse
{
void method();
};

CKlasse objekt;

Man koennte auf method() ja mit...

objekt.method();

... zugreifen.

Doch warum machen dann viele es per Zeiger:

CKlasse* pKlasse = new CKlasse;
pKlasse->method();

Ich meine, hier wuerde - aus Anfaengersicht gesehen - ja einmal ein Speicher fuer das Objekt selbst und noch fuer den Zeiger benoetigt werden.

A-jage

Mein Vorschlag: Benutze solange es geht keine Zeiger, es wird irgendwann der Tag kommen, an dem Du die Lebensdauer eines Objektes nicht mehr fest an einen Block binden kannst. Dann wirst Du schon lernen, wofür man Zeiger manchmal eben doch verwenden muss - oder Du liest die anderen Threads zu dem Thema durch

@CStoll

...oder sie wollen das Objekt etwas länger verwenden als in der Funktion, die es angelegt hat (lokale Variablen werden zerstört, wenn ihr Scope verlassen wird).

Koenntest du das vielleicht bitte mit einem Codebeispiel erklaeren...? Wie es waere mit Zeigern <-> Wie es waere ohne Zeiger... Danke!

A-jage

(für Erklärungen über den Sinn von Zeigern empfehle ich mal GPC's Magazin-Artikel "Pointer in C(++)")

void funktion()
{
   Objekt o; // am ende dieser Funktion wird o zerstört
   Objekt* p = new Objekt(); // dieses Objekt bleibt am Leben, man braucht nur einen Zeiger darauf um damit zu arbeiten
}

Eine Anmerkung zur zweiten Zeile: Der Zeiger 'p' wird am Ende der Funktion natürlich auch gelöscht, lediglich das (mit new erzeugte) Objekt, auf das er zeigt, bleibt bestehen - und wenn du seine Adresse nicht anderweitig speicherst, wirst du nach Ende der Funktion nichts mehr mit dem Objekt machen können.
(das nennt sich dann "Speicherleck")

Ich meine, man kann doch noch immer auf die Elementvariablen und Elementmethoden zugreifen oder nicht...?

A-jage

Nein. Der this-Zeiger wird ungültig nachdem der Destruktor aufgerufen wurde.

Genau genommen bleibt der Zeiger gültig, kann aber nur eingeschränkt benutzt werden - bis an der gleichen Stelle wieder ein Objekt gleichen Typs lebt. this wird ungültig - also singulär, sobald der gleiche Speicher für andere Zwecke verwendet ("reused" in standardesisch - IMO allerdings etwas unklar in seiner Bedeutung) oder freigegeben wird - aus diesem Grunde ist es erlaubt, dass der Compiler bei einem delete p den Wert des Zeigers p verändert (der Zeiger darf ohnehin nicht gelesen werden) - das kann beim Debuggen helfen.

Doch was für Folgen hat dieses "Zertören" für das weitere Arbeiten..?

Ich meine, man kann doch noch immer auf die Elementvariablen und Elementmethoden zugreifen oder nicht...?

A-jage

Der Zeiger wird nicht zerstört, er ist halt nur in der Funktion gültig, weil er dort deklariert wurde.
Und ja, du kannst noch drauf zugreifen, aber du kennst ja die Adresse nicht, weil du auf p nicht zugreifen kannst, weil die Variable nur innerhalb der Methode gültig ist.
Aber ums mit meinen Worten zu erklären:
Ein Zeiger "zeigt" auf eine Speicherstelle. Diese kann auch ungültig sein (NULL).
Ein Zeiger ist nur innerhalb seines Bereiches gültig. (Klasse, Methode, global)
Solange der Speicherbereich nicht freigegeben wird (delete), bleibt der Speicherbereich gültig. Man muss nur die Adresse kennen.
rya.

THX