Klarheit bei Pointern schaffen

Hallo zusammen,

Ich schaue mir (wieder mal) alles rund um die Pointer an und bin gerade auf der Seite hier: http://www.cplusplus.com/doc/tutorial/pointers/

Dort ist dieser Satz enthalten:

Both the increase (++) and decrease (--) operators have greater operator precedence than the dereference operator (*), but both have a special behavior when used as suffix (the expression is evaluated with the value it had before being increased). Therefore, the following expression may lead to confusion:
*p++
Because ++ has greater precedence than *, this expression is equivalent to *(p++). Therefore, what it does is to increase the value of p (so it now points to the next element), but because ++ is used as postfix the whole expression is evaluated as the value pointed by the original reference (the address the pointer pointed to before being increased).

Versteche ich denn das richtig?

bei *p++ hat die Inkrementierung die höhere Priorität als die Dereferenzierung.
Sprich zuerst wird p++ ausgeführt -> der Zeiger wird um 1 verschoben (halt je nach Datentyp-Grösse).
Danach wird das Value aus dem neuen Register zurückgegeben.

Würde ich aber nun (*p)++ schreiben, so wird der Zeiger derefenziert und der Inhalt darin um 1 erhöht (Weil die Klammern eine noch höhere Priorität als die Inkrementierung haben)?

Gruss,
swissdude

Shade Of Mine

swissdude schrieb:

Danach wird das Value aus dem neuen Register zurückgegeben.

Nein.
*p++ ist das selbe wie

T t=*p;
++p;

also es wird der alte Wert zurück gegeben.

Der Rest ist korrekt.

HighLigerBiMBam

Wenn du *p++ schreibst dann bekommst du den Wert *p zurück, änderst aber den pointer, denn dieser zeigt dann auf das folgeelement.

int arr[] = {0,1,2,3};
int *p = arr;

cout << *p << endl;
cout << *p++ << endl;
cout << *p << endl;

Verstanden?

huhu

#include <iostream>
using namespace std;

int main()
{
    int ar[5] = {0,1,2,3,4};
    int* pi = &ar[0];

    /*
        post- und prefix operator werden immer zuerst ausgeführt:
            --> pi++
                --> da aber postfix, wird hierbei noch mit dem alten Wert gearbeitet.
                    --> also "praktisch" *pi
    */
    cout << *pi++; // Ausgabe 0

    cin.get();
    return 0;
}

Also du musst das so sehen:
- Postix erhöht/verringert zwar den Wert um 1, gibt aber den alten Wert zurück.
- Also erst wenn du das nächste Mal die Variable benutzt, hast du den veränderten Wert.

Vicious Falcon

Fast alles ist richtig, jedoch eine grundlegende Sache ist falsch.
Das Postinkrement (i++) bedeutet, i holen und anschließend i ums eins erhöhen.
Das Präinkrement (++i) bedeutet, i ums eins erhöhen und holen.
*p++ bedeutet also, p holen, *p zu dereferenzieren und anschließend p erhöhen.
*(++p) dereferenziert im Gegensatz dazu das nächste Element von p.

Alles klar

Vielen dank!