C++ Was passiert in diesem C++ Code?

[Peter_2498]

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

*(p++) = *p + *p++

Ich verstehe nicht genau, nach welchen Regeln ich hier vorgehen muss.

 

[Marcel^]

Was glaubst du denn, was passiert und was wünschtest du dir, wie du vorgehen müsstest, um was zu erreichen?

 

[Flossen_Gaming]

Sieht für mich nach einer Schleife oder einer Aufzählung aus

 

[scooter010]

Antwort ist einfach:
Aufgrund von Compileroptimierungen würde der Code entfernt und nicht ausgeführt.

Edit:
Es ist eine Variante, um mit Pointern arbeiten zu lernen. Es wird nicht arr[0] + arr[1] geschrieben, sondern das array wird auf ein integer pointer gecastet.
Und die *(p++) schreibweise bewirkt auch noch etwas in der Ausführungsreihenfolge (denke ich) im Vergleich zur *p++ Schreibweise auf der anderen Seite des Zuweisungsoperators.
Wenn ich wetten müsste, steht am Ende an arr[1] der Wert 3.

 

[KitKat::new()]

Sieht für mich nach einer Schleife oder einer Aufzählung aus

Wo soll da eine Schleife sein?
Aufzählung?

 

[Perdakles]

Das ist tricky, da man sich erst einmal anschauen muss welcher Operator stärker bindet (* oder ++). Wenn man das weiß, kriegt man auch relativ schnell raus was passiert. So viel mal als kleiner Hinweis ohne gleich die Lösung zu verraten ;-)

 

[=dantE=]

Es wird im erzeugten Array durch Berechnung der Wert "1" im Array durch "3" ersetzt.
Wer macht den sowas? o_O

Edit: Excel kann das auch ^^

 

[KitKat::new()]

Ich verstehe nicht genau, nach welchen Regeln ich hier vorgehen muss.

Hier sind die Regeln für die Evaluierungsreihenfolge:
https://en.cppreference.com/w/cpp/language/eval_order

 

[Peter_2498]

So wie das Array danach aussieht, passiert wohl folgendes:

*p und *p++ evaluieren beide zu eins(das ++ ist ja postfix). Danach wird der Pointer um eine Adresse inkrementiert und zeigt danach auf die zweite Stelle im Array. Dann evaluiert *p(++) zum Element an der zweiten Stelle im Array und überschreibt diesen Wert mit 2 und inkrementiert danach nochmal den Pointer p, sodass er nun auf das dritte Element im Array zeigt, also am Ende ist dann *p = 3.

 

[Renegade334]

Es wird im erzeugten Array durch Berechnung der Wert "1" im Array durch "3" ersetzt.
Wer macht den sowas? o_O

Typische Schul-/Uniaufgaben.
Hat mit der Realität nichts zu tun und soll nur zeigen, ob man Pointer und das Zusammenspiel mit Arrays verstanden hat.

 

[scooter010]

*p evaluiert niemals zu 1. Bestenfalls zu 0x1, denn es ist ein Zeiger.

 

[KitKat::new()]

Das ist beides das selbe. 0x1 ist nur eine andere Schreibweise für 1

 

[Multivac]

So wie das Array danach aussieht, passiert wohl folgendes:

*p und *p++ evaluieren beide zu eins(das ++ ist ja postfix). Danach wird der Pointer um eine Adresse inkrementiert und zeigt danach auf die zweite Stelle im Array. Dann evaluiert *p(++) zum Element an der zweiten Stelle im Array und überschreibt diesen Wert mit 2 und inkrementiert danach nochmal den Pointer p, sodass er nun auf das dritte Element im Array zeigt, also am Ende ist dann *p = 3.

Unter der annahme das eine expression left to rigth verarbeitet wird. Diese annahme ist falsch.

 

[scooter010]

Das ist beides das selbe.

Ja und nein. Selbst 0x1 ist ja noch gekürzt, denn eigentlich müsste es 0x0000000000000001 heißen, womit dann auch automatisch die 64 bit Architektur geklärt wäre. Aber selbst im virtuellen Speicher einer Anwendung beginnt die main doch nicht an 0x1 auf dem Stack, da kommt doch noch einiges an libc Kram und die #begin oder #start oder wie die bei c hieß...

 

[Peter_2498]

Unter der annahme das eine expression left to rigth verarbeitet wird. Diese annahme ist falsch.

Eigentlich habe ich angenommen, dass es von rechts nach links ausgewertet wird.

 

[Kristatos]

Der Code macht so keinen Sinn.
*(p++) -> dass ++ erhöht den Zeiger erst DANACH

*p holt oder schreibt den Wert aus dem Speicherbereich, auf den p gerade zeigt
nach int *p = arr zeigt er auf den ersten Wert von arr bzw. arr[0]
p++ erhöht den Zeiger um einen Wert (DANACH!), würde dann auf arr[1] zeigen usw.

P.S.:
Falls kein Compiler aufgesetzt ist, versuch es doch einfach mit einem Online-Compiler:
https://www.onlinegdb.com/online_c_compiler

 

[Bricki]

Also:

*p dereferenziert einfach die 1
*p++ dereferenzierzt auch die 1 erhöht aber den Pointer um 1. Somit steht der jetzt auf 2.
*(p++) macht das selbe wie oben es dereferenziert die 2 und schreibt da 2 rein da 1 + 1 von der vorherigen Rechnung.
Dann wird der Pointer wieder um eins nach oben geschoben und steht dann auf 3.

 

[=dantE=]

1. Zuerst wird *p ausgewertet, was den Wert 1 ergibt (weil p auf arr[0] zeigt).
2. Dann wird p um eins erhöht, sodass es auf arr[1] zeigt.
3. Anschließend wird erneut *p ausgewertet, was den Wert 2 ergibt (weil p jetzt auf arr[1] zeigt).
4. Schließlich wird *p und *p++ addiert, was 1 + 2 = 3 ergibt.
5. Jetzt wird der Wert 3 in das erste Element des Arrays geschrieben, da *(p++) den Wert von *p ändert und dann p um eins erhöht

... oder bin ich jetzt völlig deppert?

Edit: Mist ... zu spät ^^ (Egal, war mal eine willkommene Ablenkung zum nervigen SQL Kram...)

 

[Peter_2498]

Schließlich wird *p und *p++ addiert, was 1 + 2 = 3 ergibt.

*p++ ist 1.

 

[Zensai]

Das riecht arg nach Hausaufgaben und dazu gilt hier folgendes:

https://www.computerbase.de/forum/threads/fragen-hausaufgaben-co.1767679/