this - Zeiger

[Devil (Gast)]

Ich habe eine Klasse Auto erstellt.
In der Programmdatei möchte ich auf die Variablen und Methoden der 
Klasse zugreifen. Dazu habe ich zuerst ein Zeiger auf die Klasse 
erzeugt.
Nun möchte ich in dem Konstruktor den this Zeiger dem globalen Zeiger 
test übergeben. Stimmt meine Beschreibung?

Auto* test=NULL;  // Zeiger auf Klasse Auto

COM::COM() // Konstruktor
{
 ….
 test = this; // this – Zeiger -> globalen Zeiger
 ….
}

In der gleichen Programmdatei erxistiert noch eine Interruptroutine in 
der möchte ich auf die ganzen Variablen und Methoden zugreifen.
Und zwar mit dem Pfeil, Beispiel:

void interrupt(void)
{
 ...
 test->irgendeine_methode_von_klasse_auto;
 ...
 return;
}

Ich weiss nicht wie man dies exakt Beschreiben kann.

[Rufus Τ. F. (rufus)]

Naja, Dein Pointer sollte schon vom gleichen Typ sein wie die Klasse, 
die Du da verwendest. Du legst einen Pointer vom Typ "Auto" an, 
initialisierst ihn aber im Konstruktor einer Klasse COM mit dem 
this-Pointer eines Objektes.

Dann wiederum versuchst Du in Deiner Interruptroutine wiederum 
Memberfunktionen der Klasse Auto aufzurufen.

Angenommen, statt COM::COM stünde da Auto::Auto, dann würde das 
prinzipiell funktionieren (sofern denn wenigstens ein Objekt vom Typ 
Auto auch angelegt wird).

Jedoch wird Dein Pointer vom jeweils letzten Objekt des Typs Auto 
überschrieben; solltest Du ein solches Objekt als automatische Variable 
(also auf dem Stack) anlegen, dann zeigt Dein Pointer mit ziemlicher 
Sicherheit irgendwohin ins Nirvana.

Der ganze Aufriss ist aber gar nicht nötig, da Du den Zeiger auf ein 
Objekt auch völlig problemlos außerhalb des Objektes bestimmen kannst:

// Das isser, der Zeiger
Auto* pAuto = NULL;

// Hier haben wir eine Instanz der Klasse Auto
Auto MeinAuto;

// hier wird der Zeiger initialisiert
pAuto = &MeinAuto;

// und hier wird der Zeiger verwendet
if (pAuto)
  pAuto->Machwas();

Das hat den Vorteil, daß Du auch mehrere Objektinstanzen Deiner Klasse 
verwenden und auseinanderhalten kannst.

Wichtig ist, daß die Memberfunktion Machwas() als "public" deklariert 
ist, da sie sonst nicht außerhalb des Klassenkontextes aufgerufen werden 
darf.

[Devil (Gast)]

Ich habe mich da vertan. Das von vorhin ist falsch.
Hier nochmals den Code:



Auto* test=NULL;  // Zeiger auf Klasse Auto

Auto::Auto() // Konstruktor
{
 ….
 test = this; // this – Zeiger -> globalen Zeiger
 ….
}

[Devil (Gast)]

Was ist eigentlich genau der this Zeiger.
Ich möchte mein obiger Code zu Papier bringen. Ich weiss nicht wie ich 
was erklären kann.

[Devil (Gast)]

Ich bin gerade am überlegen, was passiert wenn ich im Konstruktor dies 
hier nicht ausführe: test=this

Ist der this Zeiger ein zeiger auf die eigne Klasse?

[Wolfram (Gast)]

Nein, auf die (eigene) Objektinstanz.

[Devil (Gast)]

Also wie jetzt?!

Kann mir einer genau eklären wie der this - Zeiger in dem obigen 
Programm funktioniert?

[Rufus Τ. F. (rufus)]

Deine Fragen wurden bereits beantwortet.

Lies Dir mal die verschiedenen Beiträge durch.

Ansonsten rate ich Dir, Dir mal ein Grundlagenbuch über C++ 
durchzulesen. Der Stoustrup muss es dafür gar nicht mal sein.

[Stefan B. (stefan)]

Das können viele genau erklären:
http://www.onlinetutorials.de/cpp-index.htm

Grundsätzlich musst du dir den Unterschied zwischen Klasse und 
(Objekt)instanz klarmachen. Da hapert es bei dir.

Du kannst es so machen, wie du als erstes geschrieben hast. Das hat aber 
den Haken, dass du this erst bekommst, wenn du eine Methode deiner 
Klasse (korrekt der Instanz der Klasse) aufrufst. In dem Moment ist this 
der Zeiger auf die aktuelle Instanz. Wenn du in der Methode steckst, 
kannst this an test zuweisen.

Das Verfahren von Rufus ist wesentlich eleganter. In dem Moment wo du 
eine Instanz deiner Klasse anlegst, kannst du im nächsten Augenblick die 
Adresse davon holen (&) und dann damit deinen Zeiger auf die Instanz 
initialisieren. Du brauchst nicht erst eine Methode der frisch 
angelegten Instanz aufzurufen, um an this zu kommen.

[Rufus Τ. F. (rufus)]

> (...) Das hat aber den Haken, dass du this erst bekommst,
> wenn du eine Methode deiner Klasse (korrekt der Instanz
> der Klasse) aufrufst. In dem Moment ist this der Zeiger
> auf die aktuelle Instanz. Wenn du in der Methode steckst,
> kannst this an test zuweisen.

Nun, da die Zuweisung im Konstruktor abläuft, ist diesbezüglich kein 
Unterschied festzustellen. Der Konstruktor wird ja beim Anlegen einer 
Instanz automatisch aufgerufen.

Das ist nicht der wesentliche Unterschied "meiner" Vorgehensweise und 
der von "Devil" angedachten.

[Stefan B. (stefan)]

Stimmt, die Position im Konstruktor habe ich nicht beachtet.

Unelegant ist es dennoch. Bereits bei zwei Instanzen derselben Klasse 
wird es leicht fuddelisch. Hast du ja auch schon drauf hingewiesen.

"test" ist ja erstmal nur EIN globaler Zeiger auf eine Instanz der 
Klasse Auto. Den könnte man zwar ausserhalb des Konstruktors umkopieren 
- dann kann man aber auch gleich ausserhalb alle benötigten Zeiger 
anlegen.

[Karl H. (kbuchegg)]

Rufus t. Firefly wrote:
>
> Das ist nicht der wesentliche Unterschied "meiner" Vorgehensweise und
> der von "Devil" angedachten.

Richtig.

Der wesentliche Unterschied liegt in der Sichtweise der Dinge.
Eine Klasse (ein Objekte einer Klasse) ist in erster Linie
sich selbst verpflichtet und kümmert sich um seine ureigensten
Belange. Was kümmert es den Konstruktor einer Klasse oder
generell ein Objekt einer Klasse, wenn es einen globalen
Zeiger auf dieses Objekt gibt? Richtig. Gar nichts. Das
geht das Objekt nichts an. Daher ist auch nicht zuständig
dafür, dass dieser Zeiger eingerichtet wird.

Teil des Erlernens der objektorientierten Sichtweise ist es,
Zuständigkeiten zu erkennen und konsequent durchzuziehen.
Ein Auto-Objekt ist nicht dafür zuständig einen externen
Pointer auf sich selbst einzurichten. Das ist die Aufgabe
dessen, der das Auto Objekt 'verwaltet'.
Beherzigt man diese Dinge nicht, dann arten objektorientierte
Programme, wenn sie größer werden, schnell in Chaos aus. Der
vermeintliche 'kurze Hack' erweist sich dann sehr oft als der
Bumerang.