int stack[SIZE], *p;

p = stack; /* p zeigt auf das obere Ende des Stacks */

Nach meinem Verständnis sollte nun p mit dem Wert befüllt werden, welcher in stack[0] liegt, nicht aber die Adresse von stack[0] enthalten, wie im Kommentar beschrieben.

Nach meinem Verständnis ist p ein Zeiger, welcher somit immer nur Adressen speichert. Um ihn aber die Adresse von stack[0] zuzuweisen sollte es doch eher so funktionieren:

p = &stack;

Edit: Und zu SIZE habe ich auch noch eine Frage: Ist das ein fester Wert oder steht er hier im Beispiel vielleicht nur für einen belieben Wert?

SIZE muss ein zur Kompilierzeit bekannter wert sein.

Mit folgender Aussage macht natürlich alles wieder einen Sinn:

Ein Array-Name ohne einen Index == ein Zeiger auf das erste Element des Arrays

p == &p[0]

Ein Array-Name ohne einen Index == ein Zeiger auf das erste Element des Arrays

p == &p[0]

Eben nicht ganz gleich, sondern implizit konvertierbar. Den Unterschied siehst du beispielsweise, wenn du den sizeof -Operator anwendest.

Ein Array-Name ohne einen Index == ein Zeiger auf das erste Element des Arrays

p == &p[0]

Du hast da zweimal die gleiche Variable.

Ansonsten wird er nur in einen Zeiger umgewandelt und ist nicht gleich, aber das ist fürs erste vielleicht zu pingelig..

mtepe schrieb:

Ein Array-Name ohne einen Index == ein Zeiger auf das erste Element des Arrays

p == &p[0]

Du hast da zweimal die gleiche Variable.

Ansonsten wird er nur in einen Zeiger umgewandelt und ist nicht gleich, aber das ist fürs erste vielleicht zu pingelig..

Öhm Missverständins ??? oder mein Fehler?

mit

p == &p[0]

Wollte ich zum Ausdruck bringen dass p gleich &p[0] ist.(Bzw. p &p[0] entspricht)

Nexus schrieb:

Eben nicht ganz gleich, sondern implizit konvertierbar. Den Unterschied siehst du beispielsweise, wenn du den sizeof -Operator anwendest.

Hmmm hoffe das es für die Praxis keinen Unterschied da ich zugegebenermaßen noch nicht nachvollziehen kann was implizit konvertierbar meint. Den sizeof -Operator hatte ich bis jetzt noch nicht. Denke aber das wird noch auf mich zukommen

Probier das mal aus, dann siehst du, dass es nicht dasselbe ist:

int a[2];
int* pa = a; //implizite Umwandlung von einem Array Typen in einen Zeiger Typen

pa++;
a++;

Implizit heisst nur, dass du dich nicht drum kümmern musst. Eine explizite Umwandlung wäre das hier:

int* pa = static_cast<int*>(a);

Was eigentlich das ist, was gemacht wird, nur eben ohne dein zutun.

EDIT:
sizeof gibt dir die statische Grösse eines Typen, welcher bei einem Array ermittelt werden kann und somit die Grösse des Arrays zurückgibt und bei einem Zeiger eben nur die Grösse des Zeigers, was i.d.R 4 ist.

double Array[3];
double* Ptr = Array;
double* Ptr2 = &Array[0];

sizeof(Array);   // das wäre die Grösse des Arrays, also 3 mal die Grösse von double
sizeof(Ptr);     // hier würdest du die Grösse eines Zeigers erhalten, meistens 4 Byte
sizeof(Ptr2);    // ebenfalls sizeof(double*), also meistens 4

a++

Verursacht einen Fehler: error: lvalue required as left operand of assignment

Also noch einmal für mein Verständnis:

Ein Array-Name ohne einen Index enthält enthält die Adresse des Array ist aber kein Zeiger. Kann aber wiederum in der Praxis dazu genutzt werden um einem Zeiger die Adresse des Arrays zuzuweisen?

Das

a++

Verursacht einen Fehler: error: lvalue required as left operand of assignment

Also noch einmal für mein Verständnis:

Ein Array-Name ohne einen Index enthält enthält die Adresse des Array ist aber kein Zeiger. Kann aber wiederum in der Praxis dazu genutzt werden um einem Zeiger die Adresse des Arrays zuzuweisen?

Ja, das kommt so hin. Also du hast dann einen Zeiger auf das erste Element im Array.

mtepe schrieb:

Ein Array-Name ohne einen Index enthält enthält die Adresse des Array ist aber kein Zeiger. Kann aber wiederum in der Praxis dazu genutzt werden um einem Zeiger die Adresse des Arrays zuzuweisen?

Ja, das kommt so hin. Also du hast dann einen Zeiger auf das erste Element im Array.

Da bin ich nicht ganz einverstanden. Es ist zwar ein Detail, aber besser, man lernt es gleich richtig.

Der Array-Name bezeichnet das Array als Objekt an sich. Das hat rein gar nichts mit Adressen oder Zeigern zu tun. Arrays sind eigene Datentypen und in erster Linie meint man mit dem Bezeichner das Array selber und keinen Zeiger.

int Array[5];
Array; // der Typ dieses Ausdrucks ist int[5], nicht int*

Erst in gewissen Kontexten, zum Beispiel bei

int* Ptr = Array;

wird das Array in einen Zeiger auf den Anfang des Arrays umgewandelt. Damit verliert man beispielsweise auch die Grösseninformation, die man beim Array als Objekt noch hat.

Warum sieht man in den meisten Beispielen folgende Variante der Zeiger-Deklaration:

int* zeiger

und nicht

int *zeiger

hat das einen praktischen Nutzen oder ist das einfach nur so?

Denn gerade bei mehren Zeigern ist doch die zweite Variante einfacher zu lesen

int *zeiger1, *zeiger2, keinZeiger

Dies hingegen hat mich als Anfänger schon erstmal überlegen lassen

int* zeiger1, zeiger2

hat das einen praktischen Nutzen oder ist das einfach nur so?

Nein, es ist egal, aber viele Leute denken dass der * eben zum Typ gehört und der Typ also "char*" ist.

es gibt aber auch viele Leute die aus dem selben Grund "char *p" logischer finden

Dies hingegen hat mich als Anfänger schon erstmal überlegen lassen

int* zeiger1, zeiger2

nur 1 variable auf einmal deklarieren. dann spart man sich solche verwirrungen komplett.