Programming

#include <iostream>
using namespace std;

int main()
{
const int l_test = 999999999;
int *l_ptr = (int*) &l_test;

cout<<"Constant Addr:"<<&l_test<<" Value:"<<l_test<<endl;
cout<<"Pointer Addr:"<<l_ptr<<" Value:"<<*l_ptr<<endl;

*l_ptr = 888888888; // Manipulating the pointer

cout<<"-------------------------------"<<endl;
cout<<"Constant Addr:"<<&l_test<<" Value:"<<l_test<<endl;
cout<<"Pointer Addr:"<<l_ptr<<" Value:"<<*l_ptr<<endl;

return 0;
}

The o/p for this program is

Constant Addr:0012FF7C Value:999999999
Pointer Addr:0012FF7C Value:999999999
-------------------------------
Constant Addr:0012FF7C Value:999999999
Pointer Addr:0012FF7C Value:888888888

please look into the last 2 lines,
the question is : how can same address 0012FF7C have 2 different values 888888888 & 999999999
Thanks ,

You're violating basic rules. You tell the compiler l_test is a constant. That means you GUARANTEE not to mess with it - specifically you say 'I promise I will not change this to 888888888'.

What you're seeing is called 'undefined behavior', because you broke all the rules.

Indeed, you're breaking the rules. If you made I_test a global variable, your program would probably segfault as it attempted to write to protected memory! But since it's a stack variable it can't protect it from roundabout tampering like this.

What's probably happening is the compiler is going "Hmm, since it's a constant, I don't have to actually *read* it every time -- it won't change. I'll just keep it in a CPU register to save time." So when you change the memory, the copy in the register doesn't change with it.

The const specifier is more a reminder to the programmer, to tell them that they're really not supposed to be writing to some memory from this function. The truly determined might get around that with pointers and typecasting, but if you made it const in the first place you probably had a reason.