issue related to const and pointers

Question

I have written 2 programs. Please go through both the programs and help me in understanding why variable 'i' and '*ptr' giving different values.

//Program I:
//Assumption: Address of i = 100, address of ptr = 500

int i = 5;
int *ptr = (int *) &i;

*ptr = 99;

cout<<i; // 99
cout<<&i;// 100
cout<<ptr; // 100
cout<<*ptr; // 99
cout<<&ptr; // 500
//END_Program_I===============

//Program II:
//Assumption: Address of i = 100, address of ptr = 500
const int i = 5;
int *ptr = (int *) &i;

*ptr = 99;

cout<<i; // 5
cout<<&i;// 100
cout<<ptr; // 100
cout<<*ptr; // 99
cout<<&ptr; // 500
//END_PROGRAM_II===============

The confusion is: Why variable i still coming as 5, even though *ptr ==99?

because variable "i" is constant, and you cannot change the value of constant — mack, Jan 27 '12 at 07:25
But you can see that the address present in pointer 'ptr'== 100. That means, you should get the same result when you write: 1). "cout< — Jatin, Jan 27 '12 at 07:30
go through this link http://duramecho.com/ComputerInformation/WhyHowCppConst.html — User97693321, Jan 27 '12 at 07:32
possible duplicate of [Why does compiler allow you to "write" a const variable here?](http://stackoverflow.com/questions/4199950/why-does-compiler-allow-you-to-write-a-const-variable-here) — Bo Persson, Jan 27 '12 at 07:34

Mysticial · Accepted Answer · 2012-01-27T07:32:22.507

6

In the following three lines, you are modifying a constant:

const int i = 5;
int *ptr = (int *) &i;

*ptr = 99;

This is undefined behavior. Anything can happen. So don't do it.

As for what's happening underneath in this particular case:

Since i is const, the compiler assumes it will not change. Therefore, it simply inlines the 5 to each place where it is used. That's why printing out i shows the original value of 5.

edited Jan 27 '12 at 07:32

answered Jan 27 '12 at 07:24

Mysticial

464,885
45
335
332

but my doubt is that it should either print output as 5 or 99 for both the following statements: 1). cout< – Jatin Jan 27 '12 at 07:46
What's happening is that `i` does in fact have a memory location. And you are overwriting it with `99`. Therefore when you access it with `*ptr` you get 99. But since `i` is declared `const`, the compiler (legally) replaces `cout< – Mysticial Jan 27 '12 at 07:48

Emilio Garavaglia · Answer 2 · 2012-08-18T13:15:28.557

All answer will probably talk about "undefined behavior", since you are attempting the logical nonsense of modifying a constant.

Although this is technically perfect, let me give you some hints about why this happens (about "how", see Mysticial answer).

It happens because C++ is by design an "imperfectly specified language". The "imperfection" consist in a number of "undefined behaviors" that pervade the language specification.

In fact, language designers deliberately choose that -in some circumstances- instead of say "if you do this, will gave you that", (that may be: you got this code, or you got this error) thay prefer to say "we don't define what will happen".

This lets the compiler manufacturers free to decide what to do. And since there are many compiler working on many platforms, may be the optimal solution for one in not necessarily the optimal solution for another (that may have rely to a machine with a different instruction set) and hence you (as a programmer) are left in the dramatic situation that you'll never know what to expect, and even if you test it, you cannot trust the result of the test, since in another situation (compiling the same code with a different compiler or just a different version of it, or for a different platform) it will be different.

The "bad" thing, here, is that a compiler should warn when an undefined behavior is hit (forcing a const should be warned as a potential bug, especially if the compiler does const-inlining otimizations, since it is a nonsense if a const is allowed to be changed), as mot likely it does, if you specify the proper flag (may be -W4 or -wall or -pedantic or similar, depending of the compiler you have).

In particular the line

int *ptr = (int *) &i;

should issue a warning like: warning: removing cv-qualifier from &i.

So that, if you correct your program as

const int *ptr = (const int *) &i;

to satisfy the waarning, you wil get an error at

*ptr = 99;

as error: *ptr is const

thus making the problem evident.

Moral of the story:

From a legal point of view, you wrote bad code since it is -by language definition- relying on undefined behavior.

From a moral point of view: the compiler kept an unfair behavior: performing const-inlining (replacing cout << i with cout << 5) after accepting (int*)&i is a self-contradition, and incoherent behavior should at least be warned. If it wants to do one thing must not accept the other, or vice-versa.

So check if there is a flag you can set to be warned, and if not, report to the compiler manufacturer its unfairness: it didn't warn about its own contradiction.

score 2 · Answer 3 · answered Jan 27 '12 at 07:25

const int i = 5;

Implies that the variable i is a const and it cannot/should not be changed, it is Imuttable and changing it through a pointer results in Undefined Behavior.

An Undefined Behavior means that the program is ill-formed and any behavior is possible. Your program might seem to work as desired, or not or it might even crash. All safe bets are off.

Remember the Rule: It is Undefined Behavior to modify an const variable. Don't ever do it.

score 1 · Answer 4 · answered Jan 27 '12 at 14:32

1

You're attempting to modify a constant through a pointer, which is undefined. This means anything unexpected can happen, from the correct output, to the wrong output, to the program crashing.

answered Jan 27 '12 at 14:32

MGZero

5,812
5
29
46

issue related to const and pointers

4 Answers4