Frage zu den zeigern

Namal

Hallo ich habe ein frage zu den zeigern: Was bedeutet "referenzieren" und "dereferenzieren" bzw. wieso schreibt man beim ersten

int *ap;
    ap=a;

also in der zweiten zeile ohne *

und beim zweiteren

*ap = ...

cooky451

int* p = q; // Hier weißt du dem Zeiger selbst etwas zu, trotz *
p = q; // Genau so wie hier
*p; // Hier dereferenzierst du den Zeiger.
*p = 3; // Hier weißt du der Variable auf die der Zeiger zeigt etwas zu

SeppJ

*zeiger ist das, worauf der Zeiger zeigt.

int a;
int *b;

b = &a; // b zeigt auf a

*b = 2;  // hier wird a verändert.

Das hängt davon ab, was du bei dem Zeiger ändern willst.

Die Adresse wohin er zeigt, wird ohne dem * angesprochen.
Den Wert an der Adresse wo der Zeiger hinzeigt wird mit dem * angesprochen.
Die Adresse einer Variablen bekommst u mit dem Adressoperator &.

int *ap *bp, i, j;
    ap = &i;	// ap zeigt auf i. 

    *ap = 5;     //  Da ap auf i zeigt, wird i verändert 
    bp = ap;    // ap zeigt auf die selbe Adresse wie ap

    ap = &j;	// ap zeigt auf j. 
    *ap = 6;	//  Da ap auf j zeigt, wird j verändert 
    *bp = 7;	//  Da bp auf i zeigt, wird i verändert

Namal

Danke für die Antworten, also wäre diese zeile

int* p = q; // Hier weißt du dem Zeiger selbst etwas zu, trotz *

schon eine Referenzierung ? Außerdem habe ich eine andere frage, darf man einm double zeiger auf eine integervariable zeigen lassen und umgekehrt?

DocShoe

Nein, das ist keine Referenzierung, sondern eine Zuweisung. Du weist der Zeigervariable p den Wert der Zeigervariable q zu, damit zeigen p und q auf die gleiche Adresse.
Grundsätzlich darf man alles auf alles zeigen lassen, wie sich das Ganze dann aber beim Zugriff verhält ist nicht definiert. Hängt vom Anwendungsfall ab, manchmal ist es erwünscht, manchmal nicht.

SeppJ

Namal schrieb:

Danke für die Antworten, also wäre diese zeile
int* p = q; // Hier weißt du dem Zeiger selbst etwas zu, trotz *
schon eine Referenzierung ?

Hier passiert das gleiche, als wenn du

int a = 5;

schreibst. Es wird eine Variable p vom Typ int* definiert, die mit dem Wert q initialisiert wird (q muss daher auch schon ein int* sein). Das Sternchen ist in diesem Zusammenhang keine Dereferenzierung, sondern sagt, dass p ein Zeigertyp sein soll.

(Achtung, häufiger Fehler:

int* a,b,*c;

Hier ist a ein Zeiger auf int, b ein int, c ein Zeiger auf int. Das Sternchen gehört nicht zum Typen, sondern zum Variablennamen, auch wenn es den Typen der Variable ändert. Daher schreibt man oft

int *a, b, *c;

oder lässt mehrere Definitionen in einer Zeile besser gleich sein, wenn dies verwirrend sein könnte)

Außerdem habe ich eine andere frage, darf man einm double zeiger auf eine integervariable zeigen lassen und umgekehrt?

Jain. Du darfst nicht. Aber du kannst es durch reinterpret_casts trotzdem so hinbiegen. Es wird auch nicht das passieren, was du vielleicht denkst. Es wird einfach Mist rauskommen, sofern du nicht die genauen technischen Hintergründe kennst.

Normalerweise darf ein Zeiger nur auf spezialisiertere Typen zeigen (oder solche mit lascheren Qualifizierern):

class base{}; class derived: public base {};

int variable;
const int konstante;

int *a;
a = &variable; // ok
a = &konstante; // nicht ok

const int *b;
b = &variable; // ok
b = &konstante; // ok

base basis;
derived abgeleitet;

base *c;
c = &basis; // ok
c = &abgeleitet; // ok, abgeleitet ist ein base

derived *d;
d = &basis; // nicht ok, ein base ist nicht unbedingt ein derived
d = &abgeleitet; // ok

Ich hoffe übrigens mal, dass du schon C++ kannst und nun aus Not oder Interesse die Zeiger lernst. Dies sollte nämlich nicht unbedingt der normale Grundstoff für C++ sein, da es in C++ oft wesentlich bessere Lösungen als Zeiger gibt.

Namal

[quote="SeppJ"]Also wird mit

int* p = q;

Eine zeigervariable zugewiesen, das heißt dann *p zeigt auf dieselbe variable wie *q, richtig?

und irgendwo muss ich dann noch festlegen worauf *q zeigt und das mache ich mit dem referenzieren

q=&a;

Ok ich les mir erstmal das durch

http://www.cplusplus.com/doc/tutorial/pointers/

Nicht ganz

*p bzw *q sind Werte, in diesem Fall vom Typ int.
p und q sind die Zeiger.

p Zeigt auf den selben Wert wie q.

Sone

[quote="Namal"]

SeppJ schrieb:

Also wird mit
int* p = q;
Eine zeigervariable zugewiesen, das heißt dann *p zeigt auf dieselbe variable wie *q, richtig?

Jo. Prinzipiell ist das eine normale Initialisierung, deswegen ist das für dich möglicherweise etwas verwirrend; stell es dir so vor:

[TYP] [IDENTIFIER] = [WERT];

Hier ist TYP int* , IDENTIFIER ist p und WERT ist q (s Wert :D). Das nennt sich copy-initialisation.

P.S.: Ich würde übrigens nicht *q und *p schreiben, genau genommen müssen die Sternchen da weg

DirkB schrieb:

p Zeigt auf den selben Wert wie q.

Eine ziemlich lustige Erklärung. Du meinst, q zeigt auf dieselbe Variable

SeppJ

Namal schrieb:

und irgendwo muss ich dann noch festlegen worauf *q zeigt

Nicht irgendwo, sondern irgendwo vorher.