const int ändern...

[ffGebaeck]

Also, folgendes seltsames Phänomen,

ich hab ein bisschen gebastelt, wollte einen

const int ändern, hab auch was gefunden was ihn ändert,

aber irgendwie nicht richtig.

const int nConstWert = 100;

int* pAufConstWert = const_cast<int*>(&nConstWert);

* pAufConstWert = 50;

int nErgebnis = nConstWert + 50;

Wenn man im Debugger den Code durchgeht und die Variablen

überwacht, ändert sich der const int tatsächlich auf 50,

wenn ich aber mit dem const rechne, und z.B. 50 addiere kommt 150 raus, er behält also den alten wert irgendwo zum rechnen, in der Speicherzelle steht aber 50.

Wo behält er den alten Wert und weshalb ist des so?

Ich benutz VisualC++6.0

JO;)

[DocMabuse]

Andere Frage: Warum willst Du einen const int-Wert ändern? Das const wäre dann ja total sinnlos.

Normalerweise initialisierst Du so einen Wert und veränderst ihn dann nicht mehr.

Aber vielleicht gibt es einen Grund für Dein Vorhaben??? :confused:

Grüsse!

DocMabuse

[Klotzkopp]

Ein Schreibzugriff auf eine const-Variable mittels const_cast führt zu undefiniertem Verhalten.

Probier mal:

int nErgebnis = *pAufConstWert + 50;

[gugelhupf]

Nur so auf die Schnelle: hab das auch mal gebraucht, allerdings waren meine Deklarationen Zeigerorientiert:

Mit diesem Code klappt die Const-Veränderung:

#include <iostream.h>

int main()

{

const int* y=new int;

int* x=new int;

x=const_cast<int*>(y);

*x=30;

cout << "Test=" << *y <<"\n\r";

*x=100;

cout << "Test=" << *y <<"\n\r";

delete x,y;

return 0;

}

[ffGebaeck]

Warum ich versuch nen Const zu ändern?

Weil mir langweilig war, war eine spielerei,

aber mich würde das verhalten interessiern,

warum steht im Speicher der geänderte Wert

der Computer rechnet aber mit dem alten!

JO

[DocMabuse]

Habe das Ganze jetzt mal durch meinen Debugger gejagt und folgendes ist herausgekommen:

Der Pointer "pAufConstWert" zeigt nicht wirklich auf "nConstWert". Die Adresse ist eine andere.

Habe dann mal ein paar andere elementare Datentypen angelegt und Pointer draufzeigen lassen. Hier war alles, wie es sein sollte...

Warum das allerdings so ist, kann ich auch nicht genau sagen!

Grüsse

DocMabuse

[orsino]

Ich hab das ganze auch mal ausprobiert und festgestellt das mit den Pointer-Addressen alles stimmt. Wenn man sich den Assembler Code (ich benutze Visual C++6 als Compiler) dazu ansieht, dann ist es eigentlich ganz leicht zu erklären. Bei der Zuweisung:

int nErgebnis = nConstWert + 50;

schreibt der Compiler

int nErgebnis = 150;

das heißt der Wert steht schon zu Beginn fest im Code. Der Compiler sieht das nConstWert als konstanter Integer 100 definiert ist und ersetzt deshalb jedes Vorkommen mit dem konkreten Wert. Jede Manipulation der Variablen während des Programms bleibt also unberücksichtigt. Dieses Verhalten ist compilerabhängig und in den Standards nicht definiert. Nach der Zeile * pAufConstWert = 50;

ist jeder Ausdruck der nConstWert benutzt nicht definiert. Ich habe auf Google einige Posts zu diesem Thema gefunden und bei einigen Compilern würde 100 und bei anderen 150 herauskommen.

Um wirklich den aktuellen Wert aus dem Speicher zu lesen müsste man in dem Fall:

int nErgebnis = *const_cast<int*>(&nConstWert) + 50;

schreiben.

[hoagi]

Wirklich nen interessantes Problem.

Ich denk mir aber das bei einem C++ Compiler 150 rauskommen muß wenn man mal das folgende aus der Hilfe zu const-Values

aus dem Visual C++ 6.0 Compiler in Betracht zieht:

In C++, you can use the const keyword instead of the #define preprocessor directive to define constant values. Values defined with const are subject to type checking, and can be used in place of constant expressions. In C++, you can specify the size of an array with a const variable as follows:

const int maxarray = 255;

char store_char[maxarray]; // Legal in C++; illegal in C

Das kann meiner Meinung eigentlich nur funktionieren, wenn der

Compiler maxarray als Alias( also wie ein #define für den Wert 255 betrachtet, nur mit dem Unterschied, daß das nicht vom Präprozessor wie ein Textersatz behandelt wird, sondern vom Compiler verarbeitet wird ).

Witzigerweise lässt sich der Compiler auch nicht von Konstruktionen wie

nErgebnis = *(&nConstWert) + 50;

beeindrucken.

Er schreibt auch hier fest an der Speicherstelle von nErgebnis den

Wert 150.

mov dword ptr [ebp-74h],96h

Hoagi