A problem about the "const" of C++

NevemTeve · 08-26-2014, 12:35 PM

> Either it should not create a memory location for the constant - meaning that attempting to set a pointer to the address of the constant gives an error message

Only variables of 'register' storage class have no address, so it would be an error if the compiler gave an error

> It creates a memory location to store the value of the constant but any attempt to change the contents of that memory location would result in an error message.

Implementation detail. The compiler could have put the constant into a read-only segment, but it didn't. Maybe another version of it will do so.

psionl0 · 08-26-2014, 01:28 PM

Quote:

Originally Posted by NevemTeve

Only variables of 'register' storage class have no address, so it would be an error if the compiler gave an error

But it is not a variable, it is a constant.

As min86 pointed out:

Quote:

Originally Posted by mina86

As you can see, the “i” variable is *never* created. The compiler simply knows that “i == 10” therefore whenever “i” is used, it simply passes literal “10”.

NevemTeve · 08-26-2014, 01:34 PM

There's no constants in C, only variables with 'const' modifier. Pascal, for example, does have constants.

mina86 · 08-26-2014, 05:15 PM

Quote:

Originally Posted by psionl0

That looks like a compiler bug to me.

It is a bug… in the code.

Quote:

Originally Posted by psionl0

Either it should not create a memory location for the constant - meaning that attempting to set a pointer to the address of the constant gives an error message

This makes no sense. Taking address of a const object is valid operation thus compiler must provide a valid code for it.

Quote:

Originally Posted by psionl0

It creates a memory location to store the value of the constant but any attempt to change the contents of that memory location would result in an error message.

It will result in compile-time error unless you explicitly cast to pointer to non-const type, but at that point you have only yourself to blame.

psionl0 · 08-26-2014, 11:55 PM

I tested the "explicitly cast to pointer to non-const type" with the following code snippet:

Code:

#include <iostream>
using namespace std;

void changeConstant(int *p) {
   *p = 20;
   cout << "within function i = " << *p << endl;
}

int main(int argc, char **argv) {
   const int i = 10;
   cout << "i = " << i << endl;
   changeConstant(&i);
   cout << "now i = " << i << endl;
}

and got the expected error message: error: invalid conversion from 'const int*' to 'int*' [-fpermissive]

but change the function call to changeConstant((int*)&i);
and suddenly all is forgiven and the program gives the output:

Code:

i = 10
within function i = 20
now i = 10

It shouldn't be so.

ETA Interestingly, the compiler won't allow the following:

Code:

#include <iostream>
using namespace std;

void changeConstant(int &p) {
   p = 20;
   cout << "within function i = " << p << endl;
}

int main(int argc, char **argv) {
   const int i = 10;
   cout << "i = " << i << endl;
   changeConstant((int)i);
   cout << "now i = " << i << endl;
}

error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'

dy20082250 · 08-27-2014, 12:03 AM

Quote:

Originally Posted by sundialsvcs

Quite honestly, friend, you need to "mash the Pause button" on your premature attempts to write C++, with or without the helpful-advice of your compadre, and spend some time learning about the language! There are plenty of books, online and otherwise, which talk about the various language features, and you need to stop and read them!

I'm trying to say that in the very nicest possible way, and with the purpose of being helpful. (This is not "RTFM.™") Because, what you're doing right now is banging your head against things that you barely (if at all) understand, when the ability to fully understand them will only take a little more of the time that you are wasting right now. Quit stumbling around in the dark: turn on the lights, get a map, and stop and read it. You have a well-defined goal to reach ("understanding"), and what you're doing right now is a hopelessly-inefficient non-method of getting there.

I know the inline function ,but I really do not know the meanning of "using a variable inlined"

You are right,there is so much konwledge that I need to learn.

NevemTeve · 08-27-2014, 12:10 AM

Just forget the 'inlined variable', and try 'const volatile'. When it is done, remember never doing this again.

(You may have heard Ted Ts'o saying: "...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee.")

dy20082250 · 08-27-2014, 12:14 AM

Quote:

Originally Posted by psionl0

I tested the "explicitly cast to pointer to non-const type" with the following code snippet:

Code:

#include <iostream>
using namespace std;

void changeConstant(int *p) {
   *p = 20;
   cout << "within function i = " << *p << endl;
}

int main(int argc, char **argv) {
   const int i = 10;
   cout << "i = " << i << endl;
   changeConstant(&i);
   cout << "now i = " << i << endl;
}

and got the expected error message: error: invalid conversion from 'const int*' to 'int*' [-fpermissive]

but change the function call to changeConstant((int*)&i);
and suddenly all is forgiven and the program gives the output:

Code:

i = 10
within function i = 20
now i = 10

It shouldn't be so.

In c and C++,there is difference

here is my testing in c:

#include <stdio.h>

const int j=100;
int main(int argc, char* argv[])
{

const int i=10;
int *pi=(int *)&i;

int *pj=(int *)&j;
*pi = 111;

printf("%d\n",i);
printf("%d\n",*pi);
printf("%d",j);

printf("%d",*pj);

return 0;
}

the result is

111
111
100
100

when i try to do this "*pj=10000",the program is terminated

but in c++, the "i" doesn't change !

I think it is a kind of compiler optimization of C++

NevemTeve · 08-27-2014, 12:20 AM

Kindly use [code] and [/code] tags, it cannot be that difficult.
Also you could add some explanation to your printf's, eg:

[code]

Code:

printf("after setting i to 20, i=%d, *pi=%d, j=%d\n",i, *pi, j);

[/code]

PS: Yes, it is a kind of optimization: specifying 'const' you give permission the compiler to use it as a constant... It's 'const volatile' that prevents this.

psionl0 · 08-27-2014, 12:31 AM

Quote:

Originally Posted by dy20082250

In c and C++,there is difference

I wasn't aware that C recognized the 'const' modifier but I have been out of date on developments in the language before.

psionl0 · 08-27-2014, 01:19 AM

Quote:

Originally Posted by NevemTeve

PS: Yes, it is a kind of optimization: specifying 'const' you give permission the compiler to use it as a constant... It's 'const volatile' that prevents this.

you are right. Changing the declaration to const volatile i = 10; leads to the following output:

Code:

i = 10
within function i = 20
now i = 20

So you can override a 'const' variable by casting its address to a 'non-const' pointer. Doesn't seem like a good idea to me.

a4z · 08-27-2014, 01:22 AM

Quote:

Originally Posted by dy20082250

but in c++, the "i" doesn't change !

I think it is a kind of compiler optimization of C++

changing a variable that was declared constant in C++ results in undefined behavior,
this is in the standard
so nothing can happen, or you CPU melts, or anything else
-
please use code tags!

mina86 · 08-27-2014, 07:28 AM

Quote:

Originally Posted by psionl0

but change the function call to changeConstant((int*)&i);
and suddenly all is forgiven and the program gives the output: […]
It shouldn't be so.

Like I've said. You have yourself to blame. Your code has a bug, not the compiler.

Quote:

Originally Posted by psionl0

ETA Interestingly, the compiler won't allow the following:

Code:

[…]
   changeConstant((int)i);
[…]

error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'

Because this is not how you cast to a non-const reference. Change to “(int&)” and it'll work.

Quote:

Originally Posted by psionl0

I wasn't aware that C recognized the 'const' modifier but I have been out of date on developments in the language before.

Out of date since 1989? I'm sorry if I sound condescending, but that's an interesting confession from someone who at the same time claims they found a bug in a compiler (or a language).

Quote:

Originally Posted by NevemTeve

PS: Yes, it is a kind of optimization: specifying 'const' you give permission the compiler to use it as a constant... It's 'const volatile' that prevents this.

But of course, you should almost never use volatile. Definitely not in any user-space programs.

NevemTeve · 08-27-2014, 07:45 AM

An example for volatile usage in user-land program (own experience):

Code:

static int debug= 0;
...
if (debug) {
    fprintf ("This line won't ever be printed, even if you do 'set var debug= 1' in gdb\n");
}

If no part of the source modifies 'debug', compiler will know that debug is alway zero, so setting it from debugger results nothing!

Solution: static volatile int debug= 0;