int *ap;
    ap=a;

also in der zweiten zeile ohne *

und beim zweiteren

*ap = ...

int a;
int *b;

b = &a; // b zeigt auf a

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

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

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?

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.

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/

*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.

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

und irgendwo muss ich dann noch festlegen worauf *q zeigt

Nicht irgendwo, sondern irgendwo vorher.