C++ - Casting const by using the address explanation - c++

Question

I worte the following code in c++ .
I want to do casting to a const variable and change it,
this is the code:
#include <iostream>
using namespace std;
int main()
{
int const a = 5;
int* ptr = (int*)&a;
*ptr = 10;
cout<<"a is : "<< a << endl;
system("pause");
}
This code passed the compiler, I expect the program to print an the screen 10 ,
but the result in the screen is 5.
When I run the debugger the memory in &a has been changed to 10 like I expected.
Any idea why?

Answer 1

First of all this is undefined behavior. Don't do it. Second, the compiler optimized away actually looking at the memory at &a when you print out a because you told the compiler a would never change (you said it was const). So it actually turned into...
cout << "a is : "<<5 << endl;

Answer 2

You are invoking undefined behavior with the code in question, trying to change a variable declared as const by casting away the constness is not allowed (unless the const variable is really a reference to a variable which isn't const).
One plausible, and highly likely, explanation to your result is that the compiler knows that the value of a shouldn't change, therefor it can pretty much replace all occurences of a with 5. ie. the "look up" is optimized out.
Why look at the adress of a to read it's value when it's declared as always being 5?
Let's take a look at what instructions a compiler might turn the snippet into
foo.cpp
void func (int)
{
/* ... */
}
int
main (int argc, char *argv[])
{
const int a = 10;
int * p = &const_cast<int&> (a);
*p = 20;
func (a);
}
assembly instructions of main as given by g++ -S foo.cpp
main:
.LFB1:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $32, %rsp
movl %edi, -20(%rbp)
movq %rsi, -32(%rbp)
movl $10, -12(%rbp)
leaq -12(%rbp), %rax
movq %rax, -8(%rbp)
movq -8(%rbp), %rax # store the adress of `a` in %rax
movl $20, (%rax) # store 20 at the location pointed to by %rax (ie. &a)
movl $10, %edi # put 10 in register %edi (placeholder for first argument to function)
# # notice how the value is not read from `a`
# # but is a constant
call _Z4funci # call `func`
movl $0, %eax
leave
.cfi_def_cfa 7, 8
ret
.cfi_endproc
As seen above the value of 20 is indeed put at the address stored in %rax where (%rax) contains the address of a (movl $20, (%rax)), but the argument to our call to void func (int) is the constant number 10 (movl $10, %edi).
As said earlier; the compiler assumes that the value of a doesn't change, and instead of reading the memory location every time a is used it will instead replace it with the constant value 10.