Probleme mit Sichtbarkeit von Variable und Array

freakC++

Hallo zusammen,
vielen Dank für deine Erklärung, akari und vielen Dank für deinen (wohl besseren) Lösungsvorschlag, Braunstein. Doch habe ich noch ein paar Fragen zu akaris Erklärungversuch.

Das innere Sternchen sagt dem Compiler: Es geht um Zeiger auf TRechteck. Das äußere Sternchen sagt dem Compiler: Die Adresse des inneren Zeigers soll von einem zweite, außenliegendem Zeiger als Wert gehalten werden.

1.) Der innere Zeiger ist der rechte Zeiger?
2.) Beudeutet dies, dass ich hier zwei Zeiger vereinbare? Dazu habe ich dann eine Frage. Wenn ich einen Zeiger vereinbare,
dann brauche ich ein Sternchen und kann dann auf diesen zugreifen:

int *zeiger; //Ein Zeiger = ein Sternchen
int zahl=4;
zeiger=&zahl;
*zeiger=10;  //Ich kann auf den einen Zeiger zugreifen
ShowMessage(String(zahl));

Ich habe hier den Wert einer Variablen über einen Zeiger verändert. Wenn ich nun zwei Sternchen schreibe, dann bedeutet das auch, dass ich zwei Zeiger habe. Doch wie greife ich auf den zweiten Zeiger zu (ich habe ja nur einen Variablennamen) und wie greife ich auf den ersten zu? Ich habe folgendes probiert:

int **zeiger; //Ein Zeiger(name) = zwei Sternchen?
int zahl=4;
*zeiger=&zahl;//Ist das richtig?

Wenn ich nun zwei Sternchen schreibe, wie kann ich auf beide Zeiger zugreifen. Der zuletzt gepostete Quelltext wird fehlerfrei compiliert, doch hagelt es während der Laufzeit Laufzeitfehler. Warum?

Bedeutet das nun, dass ich einen Zeiger habe (hier "zeiger" genannt) und einen weiteren Zeiger (anscheinend kein Name), der auf "zeiger" zeigt.
Wie müsste das Programm dann heißen, damit es dasgleiche wie das obere macht?

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

akari

Hallo

freakC++ schrieb:

Hallo zusammen,
1.) Der innere Zeiger ist der rechte Zeiger?

Nein, die Reihenfolge von innen nach außen wird von links nach rechts gelesen. Mal ein extremes Beispiel :

int *const* x;
// Bedeutet :
// 1. int 
// 2. *     -> Zeiger auf int
// 3. const -> Konstanter Zeiger auf int (int-Wert kann verändert werden, der 
//             Zeiger kann aber auf kein anderes int Zeigen)
// 4. *     -> Variabler Zeiger auf einen konstanten Zeiger auf variables int

int **zeiger; //Ein Zeiger(name) = zwei Sternchen?
int zahl=4;
*zeiger=&zahl;//Ist das richtig?
Wenn ich nun zwei Sternchen schreibe, wie kann ich auf beide Zeiger zugreifen. Der zuletzt gepostete Quelltext wird fehlerfrei compiliert, doch hagelt es während der Laufzeit Laufzeitfehler. Warum?

Dein zweifacher Zeiger sagt dem Compiler folgendes : Es gibt eine Speicherstelle, an der die Adresse einer anderen Speicherstelle steht (erstes Sternchen). An dieser zweiten Speicherstelle steht wiederrum eine Adresse einer dritten Speicherstelle (zweites Sternchen), und in dieser steht endlich der eigentliche int-Wert.
In deinem Beispiel willst du nun zwar der zweiten Speicherstelle eine gültige Adresse zuweisen, hast aber vergessen zuerstmal dem ersten Zeiger eine gültige Adresse für die zweite Speicherstelle zuzuweisen. Das ist undefiniertes Verhalten (bei mirläuft der Code sogar ohne Fehlermeldung).

Wie müsste das Programm dann heißen, damit es dasgleiche wie das obere macht?

int **zeiger;
int *buf; // Wird nur gebraucht, um den zweiten Zeiger einen gütigen Bereich zu verschaffen
zeiger = &buf; // Erster Zeiger gesetzt
int zahl=4;
*zeiger=&zahl;// Zweiter Zeiger gesetzt
buf=&zahl; // Alternativ : Zweiter Zeiger gesetzt
std::cout << **zeiger << std::endl; // Korrekt

Irgendwann wurde mal hier im Forum ein Video gepostet, das unterhaltsam grundlegende Zeigerarbeit erklärt... finds aber nicht mehr.

bis bald
akari

volkard

akari schrieb:

Irgendwann wurde mal hier im Forum ein Video gepostet, das unterhaltsam grundlegende Zeigerarbeit erklärt... finds aber nicht mehr.

Ich nehme an, Du meinst
http://cslibrary.stanford.edu/104/

akari

Hallo

Ja genau, danke volkard.

bis bald
akari

Kolumbus

Hallo Leute,

ich finde das sehr interessant hier und lese fleissig mit

mit anderen Worten:

int **pointer;         // Zeiger auf einen int-Zeiger (eine Speicheradresse die auf eine Speicheradresse zeigt die auf einen int-Wert zeigt)
int *buf;              // ein Zeiger auf einen int-Wert
pointer= &buf;         // Zeiger auf int-Zeiger bekommt eine gültige Adresse zugewiesen (nämlich die Adresse des int-Zeigers)
int zahl= 4;           // ein int-Wert wird im Speicher abgelegt
*pointer= &zahl;       // der Zeiger buf bekommt die Adresse des int-Wertes zugewiesen (in pointer steht die Adresse des Zeiger buf, welche durch die Dereferenzierung das Zuweisungsziel für die Adresse des int-Wertes darstellt)
buf= &zahl;            // dasselbe wie die Zeile darüber, nur anders ausgedrückt
std::cout << **pointer << std::endl; // dereferenziert den Zeiger pointer und den Zeiger buf, wodurch der int-Wert ausgegeben wird
std::cout << *buf << std::endl;      // dasselbe wie die Zeile darüber, nur anders ausgedrückt

richtig?

auf das Rechteck-Beispiel bezogen:

CRechteck** arrListe;                // member-Variable: Zeiger auf einen Rechteck-Zeiger

int x= ...;                          // ein int-Wert, welcher die Anzahl der Feld-(Array-)Elemente enthält
arrListe = new (CRechteck*)[x];      // Zeiger auf Rechteck-Zeiger erhält die Startadresse eines Array von Rechteck-Zeigern
arrListe[0] = new CRechteck(a,b);    // dem ersten Element des Zeigerarray wird die Adresse einer konkreten Rechteck-Instanz zugewiesen

// löschen:
for(int y= 0; y < x; y++)
    delete arrListe[y];              // die einzelnen Instanzen auf welche die Zeiger des Zeigerarray zeigen werden gelöscht
delete[] arrListe;                   // der Zeiger auf den 1. Rechteck-Zeiger wird gelöscht

akari

Hallo

@ Kolumbus : Ja, richtig

Edit : Zu meinem zweiten Beispiel noch zwei Anmerkungen :
- Wie schon erwähnt müßen die runden Klammern beim ersten new weg.
- Das zweite new müßte eigentlich auch in einer Schleife abgehandelt werden,
denn man braucht x Instanzen von CRechteck.

bis bald
akari

Kolumbus

Folglich (etwas modifiziertes Beispiel, damit es nicht so langweilig ist):

CRechteck** arrListe;                      // member-Variable: Zeiger auf einen Rechteck-Zeiger

// erstellen:
int a= 2, b= 3, x= 10;                    // a, b: Seitenlängen der Rechtecke | x: ein int-Wert, welcher die Anzahl der Feld-(Array-)Elemente enthält (hier 10)
arrListe = new CRechteck*[x];             // Zeiger auf Rechteck-Zeiger erhält die Startadresse eines Array von 10 Rechteck-Zeigern
for(int y= 0; y < x; y++)
    arrListe[y] = new CRechteck(a++,b++); // den Elementen des Zeigerarray wird die Adresse von konkreten Rechteck-Instanzen zugewiesen
                                          // die Seitenlängen werden bei jedem Durchgang um 1 erhöht

// Zugriff:
int FlaecheninhaltB= (*arrListe[1].Width) * (*arrListe[1].Height); // Flächeninhalt des 2. Rechteckes (ist 12) so ermittelbar???

// löschen:
for(int y= 0; y < 10; y++)
    delete arrListe[y];                   // die einzelnen Instanzen auf welche die Zeiger des Zeigerarray zeigen werden gelöscht
delete[] arrListe;                        // der Zeiger auf den 1. Rechteck-Zeiger wird gelöscht

Ist das mit dem Zugriff so richtig? Ich denke mir das so: arrListe[1] enthält die Adresse der 2. Rechteck-Instanz, die ich mit *arrListe[1] erhalte...!?!

akari

Hallo

Nicht ganz. Um von arrListe auf Width und Height zuzugreifen must schreiben :

(*arrListe[1]).Width // beachte die versetzte schließende Klammer
// oder
arrListe[1]->Width

bis bald
akari

Kolumbus

Ok, danke - verstanden soweit (auch wenn ich's aktuell nicht brauche).

Vielleicht hilfts ja freakC++ ein wenig beim Verständnis...

freakC++

Hallo zusammen,
vielen Dank für eure Antworten. Sie haben mir sehr geholfen und ich bin schon um einiges weiter. Ich sitze nämlich gerade hier in Frankreich in unserem Ferienhaus, schaue auf die Kuhweide und bringe mir weiter C++ bei ;). Dabei noch eure Hilfe....besser gehts nicht!!!

So, noch ein paar letzte Fragen.

1.) Kann man die Variable "buf" als eine Art Brücke ansehen ohne welche nicht auf weiter hinten stehende Variablen zugegriffen werden kann?

2.) Kann man als Schema folgendes schreiben:

int **zeiger;
// Pointer -> Pointer1 -> Variable

Bei mir war doch das Problem, dass ich zwar Pointer2 eine Adresse zugewiesen habe, doch Pointer1 ging leer aus? Ich habe also nicht ausreichend dereferenziert!?

3.) Um jetzt auf das Rechteckbeispiel nochmal zu kommen:

CRechteck **arrListe;

/*Ich erstelle einen Zeiger, der die Adresse eines anderen Zeigers enthält, wobei diese auf eine Variable vom Typ CRechteck zeigt?

arrListe --> arrListe1 --> Variable des Typs CRechteck*/

arrListe = new CRechteck *[zahl];

/*Ich weise dem ersten Pointer Speicherplatz zu?? Hier bin ich mir nicht sicher, obwohl Kolumbus ja schon etwas geschrieben hat. Könnt ihr nochmal genau sagen (so einfach wie möglich ;)), was hier genau passiert. Vielleicht könnt ihr euch ja auf akaris letztes Beispiel beziehen, denn ich denke, dass dies relativ ähnlich ist.*/

arrListe[0]=new CRechteck (4,4);

/*ich weise der ersten Instanz von CRechteck Speicherplatz zu und übergeben zwei Zahlen an den Konstruktor.*/

Warum muss ich hier nie vor arrListe ein Sternchen schreiben. Es ist doch eigentlich das gleiche wie mit **zeiger und da musste ich in einem Schritt auch *zeiger schreiben. Vorallem der zweite Quelltext ist mir wichtig, da dieser mir momentan noch Kopfschmerzen bereitet. Warum steht das Sternchen genau vor [zahl].

Vielen Dank für eure Hilfe, denn ich bin schon sehr viel weiter!

lg, freakC++

Kolumbus

freakC++ schrieb:

Hallo zusammen,
vielen Dank für eure Antworten. Sie haben mir sehr geholfen und ich bin schon um einiges weiter. Ich sitze nämlich gerade hier in Frankreich in unserem Ferienhaus, schaue auf die Kuhweide und bringe mir weiter C++ bei ;).

freakC++ schrieb:

1.) Kann man die Variable "buf" als eine Art Brücke ansehen ohne welche nicht auf weiter hinten stehende Variablen zugegriffen werden kann?

Kann man so ansehen. Du hast einen Zeiger pointer der auf buf zeigt und eine Variable (Speicherbereich) x auf die noch nichts zeigt. Wenn du buf jetzt nicht die Adresse von x gibst, kannst du mit pointer auch nix anfangen.

freakC++ schrieb:

2.) Kann man als Schema folgendes schreiben:
int **zeiger;
// Pointer -> Pointer1 -> Variable
Bei mir war doch das Problem, dass ich zwar Pointer2 eine Adresse zugewiesen habe, doch Pointer1 ging leer aus? Ich habe also nicht ausreichend dereferenziert!?

Das könnte man als abstraktes Schema so schreiben.
Genau, bei dir wurde Pointer1 nicht mit einer Adresse initialisiert.
Dereferenzieren bedeutet, dass du nicht den Wert der Zeiger-Variablen meinst, sondern das, was an der Adresse steht die in der Zeiger-Variablen gespeichert ist.
Beispiel:

int *Zeiger;
int IntVariable;
Zeiger= &IntVariable; // bedeutet die Speicheradresse von IntVariable wird im Zeiger gespeichert, egal was für einen Wert IntVariable hat
*Zeiger= 3;           // <== Dereferenzieren: du weist nicht dem Zeiger die 3 zu, sondern IntVariable (also speicherst du eine 3 an der Speicherstelle, welche von IntVariable belegt ist)

Das wiederum sollte jedoch in jedem Grundlagenbuch erklärt sein (dereferenzieren).

freakC++ schrieb:

3.) Um jetzt auf das Rechteckbeispiel nochmal zu kommen:

CRechteck **arrListe;

/*Ich erstelle einen Zeiger, der die Adresse eines anderen Zeigers enthält, wobei diese auf eine Variable vom Typ CRechteck zeigt?

arrListe --> arrListe1 --> Variable des Typs CRechteck*/

Beachte die Formulierung: Du erstellst einen Zeiger, der auf die Adresse eines anderen Zeigers zeigen kann! Der Zeiger kann auf etwas zeigen, tut es aber konkret noch nicht! Ansonsten richtig.

freakC++ schrieb:

arrListe = new CRechteck *[zahl];

/*Ich weise dem ersten Pointer Speicherplatz zu?? Hier bin ich mir nicht sicher, obwohl Kolumbus ja schon etwas geschrieben hat. Könnt ihr nochmal genau sagen (so einfach wie möglich ;)), was hier genau passiert. Vielleicht könnt ihr euch ja auf akaris letztes Beispiel beziehen, denn ich denke, dass dies relativ ähnlich ist.*/

Ja, du sagst dem 1. Pointer er soll auf die Startadresse eines Array mit <zahl> Elementen zeigen. Das Array ist vom Typ Zeiger auf CRechteck (wie es auch Arrays vom Typ char gibt). Das Array wird in dieser Zeile auch gleich im Speicher angelegt (durch das new).

Muss erstma aufhören... Rest später

freakC++

Hallo,
ok dann warte ich auf deine Fortsetzung. Zwischen durch noch das (ich habe etwas Neues ausprobiert):

int **zeiger;
 int zahl=4;
 *zeiger=&zahl;
 zeiger=&(*zeiger); //Warum geht das nicht
 ShowMessage(String(**zeiger));

Wieder kommt ein Laufzeitfehler, doch dachte ich, dass ich hier nun auch Pointer1 und Pointer2 eine Adresse zugewiesen habe! Ich habe versucht auf die Variable "buf" zu versichten

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

akari

Hallo

Bis zur dritten Zeile hast du nichts verändert, deshalb kommt der gleiche Fehler wie vorher. Vor dem Verwenden von *zeiger must du zeiger erstmal eine gülige Speicheradresse zuweisen! Und daran krankt auch das hier :

zeiger=&(*zeiger);

Denn bevor die linke Seite zugewiesen wird, wird die rechte Seite ausgewertet. Und dort verwendest du wieder *zeiger vor zeiger. Das kann so nicht klappen. Und ganz kann ich auch nicht verstehen was du damit bewirken willst. Versuchst du einen Zeiger auf sich selbst zeigen zu lassen? Ganz schlechte Idee, und auch gar nicht hilfreich bei einem Zweifach-Zeiger.

bis bald
akari

Kolumbus

So, hier wie versprochen der Rest:

freakC++ schrieb:

arrListe[0]=new CRechteck (4,4);

/*ich weise der ersten Instanz von CRechteck Speicherplatz zu und übergeben zwei Zahlen an den Konstruktor.*/

Richtig. Und dieser zugewiesene Speicherplatz kann über das 1. Element des Array (vom Typ Zeiger auf CRechteck) angesprochen werden.

Beispiel:

int FlaecheninhaltB= (*arrListe[0]).Width * arrListe[0]->Height; // beide Zugriffe auf arrListe sind gleichwertig verwendbar

freakC++ schrieb:

Warum muss ich hier nie vor arrListe ein Sternchen schreiben. Es ist doch eigentlich das gleiche wie mit **zeiger und da musste ich in einem Schritt auch *zeiger schreiben.

Felder und Zeiger sind miteinander verwandt, das spielt hierbei eine Rolle. Lies dazu bitte den Link unten.

freakC++ schrieb:

Vorallem der zweite Quelltext ist mir wichtig, da dieser mir momentan noch Kopfschmerzen bereitet. Warum steht das Sternchen genau vor [zahl].

Zum 2. Quelltext nochmal (ich glaub du meinst eher den 3. aus deinem vorletzten post): Das Sternchen gehört nicht vor [zahl] sondern hinter CRechteck! CRechteck* ist die Typangabe für das Array, welches also dann vom Typ Zeiger auf CRechteck ist.

Ich weiß auch nicht wie man es noch einfacher erklären soll. Deklarationen, Definitionen und Initialisierungen sind Grundlagen der Programmierung. Und wenn man mit Zeigern arbeiten möchte, sollte man die Grundlagen dazu zu 90% verinnerlicht haben. Dazu gehören Zeigerdeklaration, Zeigerdefinition und Zeigerdereferenzierung! Ich empfehle nochmal ein einfaches Tutorial zum Thema Zeiger (engl. Pointer) und eins zum Thema Felder (engl. Array)...

Hier mal was zum Lesen über Zeiger.

MfG

freakC++

Hallo zusammen,
vielen Dank für eure Antworten. Ich komme dem vollen Verständnis immer näher, doch merke ich, dass mich immer noch ein paar Denkfehler plagen. Die Sache mit dem Rechteck habe ich verinnerlicht. Doch ein paar Fragen zum anderen Quelltext bleiben. Ich habe mal eine kleine Zeichnung gemacht, die euch zeigen soll, wie ich mir das alles vorstelle. Folgender Quelltext nochmal:

int zahl=5;
int **zeiger;
int *buf;
zeiger=&buf;
*zeiger=&zahl;

So stelle ich mir das vor.

//Ich kann hier leider keine ASCII Zeichnungen machen. Daher hier der Link:

http://i1.fastup.de/show.asp?file=zeiger(1).jpg
(der Link ist die ganze Zeile und nicht nur das Unterstrichende)

Mein Problem ist nun die Verbindung zwischen Zeiger1 und Zeiger 2. Zeiger1 muss auch auf Zeiger2 zeigen. Wenn ich folgendes schreibe:

int **zeiger;

zeigt, dann automatisch Zeiger ein auf Zeiger 2? Wenn ja, dann müsste doch auch Zeiger1 von Anfang an eine Speicheradresse haben, denn ein Zeiger ohne Speicheradresse kann doch auf nichts zeigen.

2.)Warum muss buf ein pointer sein?? Zeiger1 braucht doch nur eine Adresse. Kann dies nicht auch eine Adresse von einer int Variablen sein?

Ich habe schon einiges zu C++ durchgearbeitet, doch hatte ich noch kein Buch, das sich derart mit Zeigern auseinander setzt. Ich werde mir wohl bald
ein anpruchvolleres kaufen. Da mich die ganze Materie total interessiert, hoffe ich zum einen auf eure Geduld und zum anderen, dass ich bald alles verstanden habe.

Vielen, vielen Dank
lg, freakC++

Kolumbus

*grummel**

freakC++ schrieb:

Wenn ich folgendes schreibe:
int **zeiger;
zeigt, dann automatisch Zeiger1 auf Zeiger 2?

NEIN! Da zeigt überhaupt noch garnix irgendwohin. Damit deklarierst du nur einen Zeiger, der auf einen anderen Zeiger zeigen KANN (vom Typ her)!
Es ist kein Zeiger auf int, sondern ein Zeiger auf Zeiger auf int!
Du hast einen Zettel auf dem steht eine Zahl (Zettel 0 = int-Variable). Dann schreibst du einen Zettel, darauf schreibst du wo der Zettel mit der Zahl liegt (Zettel 1 = Zeiger 1 oder buf). Dann schreibst du einen Zettel, auf dem steht wo der Zettel liegt auf dem steht wo der Zettel mit der Zahl liegt (Zettel 2 = Zeiger 2 oder pointer haben wir die hier glaube genannt). Wenn du jetzt vergisst auf den Zettel 1 etwas draufzuschreiben, findest du mit Zettel 2 nicht Zettel 0, weil du Zettel 2 liest, dann zu Zettel 1 gehst, da aber nichts draufsteht.

MfG

freakC++

Hallo Kolumbus,
vielen Dank...auch wenn ich wahrscheinlich für euch total duzmm erscheine. Sorry, wenn ich dich erbost habe :p . Ich habe mir alles nochmal durchgelesen und denke, dass ich es nun (endlich) verstanden habe. Noch eine Frage :

Warum muss buf selber ein Pointer sein? Wenn ich folgende schreibe, dann brauche ich sogar zwei Sterne:

int ***zeiger;
int **buf; //brauche nun zwei Sternchen
int *kuf;
zeiger=&buf; //zeiger braucht nur ne Adresse. Warum reicht nicht *buf
*zeiger=&kuf;
int zahl=5;
**zeiger=&zahl;
ShowMessage(String(***zeiger));

Auch wenn das wahrscheinlich totaler Hirngespinst ist, habe ich nun allen Zeigern eine Adresse zugewiesen. Wenn ich dem ersten Zieger (zeiger) eine Adresse zuweisen möchte, brauche ich einen Zeiger mit zwei Sternchen.
Warum? zeiger braucht doch "nur" eine Adresse. Warum nimmt er diese nicht von einem "normalen" Pointer?

int zahl=5;
int **zeiger;
int *buf;
zeiger=&buf; //Auch hier weise ich zeiger eine Adresse zu. Oben geht das 
*zeiger=&zahl; //aber nicht

Vielen Dank
lg, freakC++

kpeter

Hi,

ich denke mal, du startest deine Anwedung im Debuggermodus und setzt einen Haltepunkt auf deinen allerersten Zeiger
und setzt den Cursor darüber. In dem kleinen Hintfenster siehst du nun, wie die Variablen und Zeiger belegt sind.

Mit einem Wert oder einer Speicheraddresse. Du kannst auch das Fenster "Liste überwachter Ausdrücke" öffnen und alles dort
eintragen.

Sehr interessant !

mfg
kpeter

Kolumbus

freakC++ schrieb:

Hallo Kolumbus,
vielen Dank...auch wenn ich wahrscheinlich für euch total duzmm erscheine. Sorry, wenn ich dich erbost habe :p . Ich habe mir alles nochmal durchgelesen und denke, dass ich es nun (endlich) verstanden habe. Noch eine Frage :

Warum muss buf selber ein Pointer sein?

Damit die CRechteck-Geschichte funktioniert wie du es wünschst (wenn ich mich richtig erinnere).

freakC++ schrieb:

Wenn ich folgende schreibe, dann brauche ich sogar zwei Sterne:

int ***zeiger;
int **buf;                      // brauche nun zwei Sternchen
int *kuf;
zeiger= &buf;                   // zeiger braucht nur ne Adresse. Warum reicht nicht *buf
                                // Antwort: weil eine Adresse in C++ nunmal mit & ermittelt wird
                                // oder wie meinst du die Frage?
*zeiger= &kuf;                  // ist gleichwertig der folgenden Zeile:
    buf= &kuf;
int zahl= 5;
**zeiger= &zahl;                // ist gleichwertig den folgenden 2 Zeilen:
    *buf= &zahl;
    kuf= &zahl;
ShowMessage(String(***zeiger)); // ist gleichwertig den folgenden 3 Zeilen:
    ShowMessage(String(**buf));
    ShowMessage(String(*kuf));
    ShowMessage(String(zahl));

Auch wenn das wahrscheinlich totaler Hirngespinst ist, habe ich nun allen Zeigern eine Adresse zugewiesen.

Richtig, hier sind alle Zeiger korrekt initialisiert! Sieht ja schon ganz brauchbar aus.

freakC++ schrieb:

Wenn ich dem ersten Zieger (zeiger) eine Adresse zuweisen möchte, brauche ich einen Zeiger mit zwei Sternchen.
Warum? zeiger braucht doch "nur" eine Adresse. Warum nimmt er diese nicht von einem "normalen" Pointer?
int zahl= 5;
int **zeiger;
int *buf;
zeiger= &buf;     // Auch hier weise ich zeiger eine Adresse zu. Oben geht das aber nicht
*zeiger= &zahl;   // => das hier geht oben nicht? ist auch richtig, denn oben müsste es (wie dort bereits geschrieben) so aussehen:
    **zeiger= &zahl;

Du hast das mit den Zeigertypen noch nicht verstanden. Ein Zeiger ist eine Variable. Eine Zeigervariable enthält jedoch keinen Wert im klassischen Sinne, sondern eine Speicheradresse. Damit dein Programm später noch weiß, wie es das, worauf du mit dem Zeiger zeigst, interpretieren soll hat der Zeiger einen Typ (genau wie eine Variable). Ein Zeiger kann zB. vom Typ "Zeiger auf int" sein - dann kann in dem Zeiger eine Adresse eines Integer gespeichert werden. Der Zeiger wird so deklariert:

int* Zeiger;

So solltest auch du Zeiger deklarieren, nicht so:

int *Zeiger;

. Dann geht dir vielleicht in Fleisch und Blut über, dass das Sternchen in der Deklaration zur TYPVEREINBARUNG gehört.
Wenn du jetzt so einen int-Zeiger deklariert hast und stellst nun fest dass du aus irgendeinem Grund einen Zeiger auf diesen Zeiger brauchst, deklarierst du den Zeiger auf den int-Zeiger so:

int** Zeiger2;

Das mit dem dereferenzieren liest du dir am Besten selbst nochmal durch!

Hinweis: Das Sternchen bei der Deklaration des Zeigers hat nichts mit dem Sternchen zu tun, welches du bei der Arbeit mit dem Zeiger verwendest!

Alles was was hier versucht wird zu erklären zielt darauf ab dass du die Konstruktion / Vorschläge für das CRechteck-Projekt verstehst. Also frag' nicht wozu du Zeiger auf Zeiger brauchst - das zielt darauf ab deine Vorstellungen zu realisieren!

MfG

freakC++

Hallo Kolumbus,
viele Dank für deine Antwort.

Antwort: weil eine Adresse in C++ nunmal mit & ermittelt wird
oder wie meinst du die Frage?

Ich meine das so (die Sache mit CRechteck ist übrigens abgeschlossen):

int zahl=5;
int ***zeiger; //ich muss allen Zeigern eine Adresse zuweisen.
int *buf;
int *kuf;

zeiger=&buf; //Zeiger 1 bekommt seine Adresse
*zeiger=&kuf;//Zeiger 2 bekommt seine Adresse
**zeiger=&zahl;//nun ist das möglich und ich kann folgendes schreiben:

ShowMessage(String(***zeiger));

Dieser Quelltext ist falsch. Ich dachte jedoch, dass ich nun allen zeiger eine Adresse zugewiesen habe. Ich muss aber das schreiben:

int zahl=5;
int ***zeiger; //ich muss allen Zeigern eine Adresse zuweisen.
int **buf; //Zwei Sternchen!!!!!!
int *kuf;

zeiger=&buf; //Zeiger 1 bekommt seine Adresse
*zeiger=&kuf;//Zeiger 2 bekommt seine Adresse
**zeiger=&zahl;//nun ist das möglich und ich kann folgendes schreiben:

ShowMessage(String(***zeiger));

Warum muss ich **buf schreiben. Ich wil doch "nur" zeiger und *zeiger eine Adresse zuweisen....so wie wir es schon vorher gemacht haben.

Vielen Dank
lg, freakC++

PS.: Wenn ich diesen letzten Schritt verstandne habe, dann sage ich endlich zu diesem Thread: -close-