[C++] Konstanten "ändern" / const correctness

[CrystalCoder]

Hi,

mich hat schon immer mal interessiert, ob es irgendwie möglich ist, eine vorher definierte Kostante mit Hilfe von Pointern in ihrem Wert zu ändern.
Im Prinzip gings mir dabei nicht darum wirklich eine Konstante ändern, sondern zu schauen, ob es trotz const doch irgendwie möglich ist.

Da ich keine brauchbaren Infos dazu finden konnte, hab ich einfach mal ein wenig rumprobiert und bin auf ein Ergebnis gekommen, was ich mir nicht so richtig erklären konnte.

Code: Alles auswählen

// Die Konstante
const int A = (int) 'A';

// Hilfspointer um den Wert zu ändern
int* pA = (int*) &A;

// Wert ändern
*pA = 15;

int B = A;
int C = *pA;

// Testausgaben
printf("-------------------\n");
printf("value of A: %d\n", A);
printf("value of B: %d\n", A);
printf("value of C: %d\n", A);
printf("-------------------\n");
printf("address of a: %p\n", &A);
printf("pA pointing to: %p\n", pA);
printf("-------------------\n");

Was nun passiert, ist folgendes:

b == (int) 'A' wie erwartet
adresse von pA == &A ebenso wie erwartet
c == 15 // wieso das, wenn A garnicht geändert wurde??


Mit anderen Worten: Wenn ich nun über die Variable A zugreife (egal ob direkt den Wert oder über &A), ist alles wie es sein soll,
Benutze ich hingegen pA wird auf die geänderten Werte zugegriffen, obwohl pA == &A.

Es sieht jetzt so aus, als würde die gleiche Adresse unterschiedliche Werte beinhalten. Handelt es sich hierbei um so eine Art "Address-Mapping" zwischen Stack und Heap?

[Schrompf]

Nein, da wird nur der Compiler optimieren, indem er jedes Auftreten von A gleich direkt mit der Konstante ersetzt. Sobald Du die Adresse von A nimmst, muss der Compiler aber auch dafür sorgen, dass es die Variable physisch auch gibt. Und damit kannst Du sie dann ändern.

Das ganze Spiel gänge übrigens kürzer mit const_cast. Eine dumme Idee ist es trotzdem :-)

[CrystalCoder]

Ah verstehe, damit ergibt das auch wieder einen Sinn. Danke für die Info.
Dass es keine gute Idee ist, kann ich mir denken :)

[Krishty]

Fun facts:

• Das nennt sich Aliasing (dieselbe Variable ist unter unterschiedlichen Namen – hier unter dem Alias *pA – bekannt).
• const bedeutet nicht, dass sich ein Wert nicht ändert – es bedeutet, dass du ihn (genauer: seinen logischen Zustand) nicht ändern darfst.
• Aliasing ist einer der größten Optimierungshemmer für Compiler, weil sie annehmen müssen, dass jede Schreiboperation auch irgendwo einen zu lesenden Wert ändern könnte. Um das ausschließen und wegoptimieren zu können wird viel Logik investiert.
• Die dumme Idee kann man spezifizieren mit: Laut C++-Standard ist es undefiniert, den Zustand eines const-Objekts zu ändern, darum das kontraintuitive Verhalten.