Zeiger

Hi,

bin Anfänger und habe hierzu ein paar Fragen:

int i=4;

int *pointer_i=&i;

cout << i << pointer_i<< endl;

cout <<&i<<&pointer_i<<endl;

Ich versteh hier nur so viel:

Zeigervariable wird mit der Adresse von i initialisiert.

Was ist der Unterschied zwischen pointer_i und &pointer_i

Ich verstehe nicht warum bei pointer_i und &pointer_i verschiedene Adressen ausgegeben werden.

int var = 42;
int *pointerToVar = &var;
int **pointerToPointerToVar = &pointerToVar;

Du hast nur für die Ausgabe einen neuen Zeiger auf den vorhandenen erstellt.

Gast94 schrieb:

int i=4;

int *pointer_i=&i;

cout << i << pointer_i<< endl;

cout <<&i<<&pointer_i<<endl;
Was ist der Unterschied zwischen pointer_i und &pointer_i

Na was ist der Unterschied zwischen

cout << variable;

und

cout << &variable;

Richtig, pointer_i gibt den Inhalt des Zeigers aus. &pointer_i gibt die Adresse des Zeigers aus.

gamer8o4

pointer:

int i = 4; // normale intager variable mit dem wert 4
// mit &i bekommst du die adresse der variabe
// & ist der adressoperator mit dem du die adresse deiner variable ausliest
cout << i; //das gibt normal den wert der variable aus also 4
cout << &i; // das gibt die adresse der variable aus.

int *pointer = &i; // pointer auf einen intager dem wir die adresse von i übergeben
// pointer enthällt also die adresse von i
cout << pointer; // ist also das gleiche wie cout << &i, es gibt die adresse von i aus
cout << *pointer; // der * operator holt sich den wert an
// der adresse von pointer, pointer zeit auf I und I hat den
// wert 4, also wird 4 ausgegeben
// *pointer ist übrigens das gleiche wie *(&i) was aber wenig sinn macht
// sich erst die adresse zu holen und dann
// den wert an der adresse wieder zu suchen

pointerpointer:

wir hatten ja die adresse von i in pointer gespeichert und können über diese adresse auf I zugreifen (mit dem * operator)
jetzt stellt sich die frage was bei &pointer passiert
nun, &pointer ist die adresse von pointer, welches wiederum die adresse von I beinhaltet, also gilt folgendes:

int **pp = &pointer; // neuer pointer auf den pointer einer variable,
// der wir die auf die adresse auf pointer übergeben, welche auf i zeigt
cout << &pointer; // addresse von pointer
cout << pp; // adresse von pointer
cout << *pp; // adresse von i
cout << **pp; // i, also 4

ps:
viel genauer kamn ich es an dieser stelle nicht erklären, kauf dir am.besten ein gutes buch über c++ und lies es.
erscheint vielleicht erst recht trocken soein buch zu lesen, aber anders geht es eigentlich nicht

*Rewind*

Ich glaube, du wolltest so was haben wie:

int i=4;

int *pointer_i=&i;

cout << "[Werte] Variable: " << i << " und Zeiger: " << *pointer_i<< endl;

cout << "[Adressen] Variable: " &i<< " und Zeiger: " << pointer_i<<endl;

ScottZhang

Zeiger sind stinknormale Variablen, da stehen genauso nullen und einsen drin wie bei jeder anderen auch. Nur wird der Wert (die nullen und einsen) eines Zeiges als eine Addresse im Speicher interpretiert. Nich mehr und nich weniger.
Von daher ist zeiger der Wert und &zeiger die Addresse der Variablen zeiger.
Da wie gesagt der Wert eines Zeiger als Addresse interpretiert wird, kommt noch eine zusätzlich Operation dazu. Der unäre Operator ***. *zeiger ist der Wert der Variable mit der Addresse die in zeiger gespeichert ist.

Das wars, das sind Zeiger und größer brauch ein entsprechender Buchabschnitt auch nich sein :).