MSDN const_cast sample

[George2]

Hello everyone,


In MSDN sample for const_cast,

http://msdn2.microsoft.com/en-us/library/bz6at95h(VS.80).aspx

There is a statement like this,

--------------------
On the line containing the const_cast, the data type of the this pointer is const CCTest *. The const_cast operator changes the data type of the this pointer to CCTest *
--------------------

I think in a const member function, like void printNumber() const, the type of this pointer is const pointer to current type, so we use this const_cast to remove its const properties.

For a non-const member function, I think this pointer should not be a const pointer, right?

So, conclusion is,

1. in const member function, this pointer is a const pointer;
2. in non-const member function, this pointer is a non-const pointer.

Right?


thanks in advance,
George

[weaknessforcats]

Most of your post is so not true.

Let's take it in pieces.

First, the const member function. This is a function that cannot change the member data. Not being able to chnage the member data makes the this pointer const. I believe that ius what you concluded and you are correct.

Second, a const member function can change members of a const object if those member are marked mutable. The mutable qualifer means that the member does not participate in the const-ness of the object.

Third, in a non-const member function, the this pointer is not const and I believe this was also one of your conclusions. However, even though the this pointer is not const, you still cannot change the vaue of any const members.

Fourth, the const_cast does not remove the const. What it does is create a copy that is not const. You are free to change the copy. However, the original is untouched. Worse, the address of the original and the address of the non-const copy are reported as the same. Check this out:

int main()
{
   const int var = 1234;
   //int* ptr = &var;    //error! var is const
   int* ptr = const_cast<int*> (&var);
  *ptr = 9999;
   cout << "var using ptr = " << *ptr << endl;
   cout << "var using var = " << var << endl;
   cout << "&var using ptr = " << ptr << endl;
   cout << "&var using var = " << &var << endl;
}
 

This is vile. Now the program uses 1234 when var is used and 9999 when *ptr is used. Clearly, there are now two variables.

You see, var is const and the compiler never permits the value of a constant to change.

According to Stroustroup, using a const_cast is to change a variable is not guaranteed to work if the object was declared as const. That is, if the variable were originally non-const and was later to be accesses using a const pointer, you could const_cast the the const pointer to non-const and change the original object.

That is, a const_cast allows pointer acess to a variable but the result of using that pointer to change the value of the variable is undefined.

You see the same effect using the C-style cast that is depreacted in C++:

int main()
{
   const int var = 1234;
   //int* ptr = &var;    //error! var is const
   int* ptr = (int*)&var;
  *ptr = 9999;
   cout << "var using ptr = " << *ptr << endl;
   cout << "var using var = " << var << endl;
   cout << "&var using ptr = " << ptr << endl;
   cout << "&var using var = " << &var << endl;
}
 

[George2]

Thanks weaknessforcats,


Only one comment about the following code,

   const int var = 1234;
   //int* ptr = &var;    //error! var is const
   int* ptr = const_cast<int*> (&var);
 

I think &var is const int* type, so you need to use const_cast remove const qualifier and makes &var int* type, right?

Most of your post is so not true.

Let's take it in pieces.

First, the const member function. This is a function that cannot change the member data. Not being able to chnage the member data makes the this pointer const. I believe that ius what you concluded and you are correct.

Second, a const member function can change members of a const object if those member are marked mutable. The mutable qualifer means that the member does not participate in the const-ness of the object.

Third, in a non-const member function, the this pointer is not const and I believe this was also one of your conclusions. However, even though the this pointer is not const, you still cannot change the vaue of any const members.

Fourth, the const_cast does not remove the const. What it does is create a copy that is not const. You are free to change the copy. However, the original is untouched. Worse, the address of the original and the address of the non-const copy are reported as the same. Check this out:

int main()
{
   const int var = 1234;
   //int* ptr = &var;    //error! var is const
   int* ptr = const_cast<int*> (&var);
  *ptr = 9999;
   cout << "var using ptr = " << *ptr << endl;
   cout << "var using var = " << var << endl;
   cout << "&var using ptr = " << ptr << endl;
   cout << "&var using var = " << &var << endl;
}
 

This is vile. Now the program uses 1234 when var is used and 9999 when *ptr is used. Clearly, there are now two variables.

You see, var is const and the compiler never permits the value of a constant to change.

According to Stroustroup, using a const_cast is to change a variable is not guaranteed to work if the object was declared as const. That is, if the variable were originally non-const and was later to be accesses using a const pointer, you could const_cast the the const pointer to non-const and change the original object.

That is, a const_cast allows pointer acess to a variable but the result of using that pointer to change the value of the variable is undefined.

You see the same effect using the C-style cast that is depreacted in C++:

int main()
{
   const int var = 1234;
   //int* ptr = &var;    //error! var is const
   int* ptr = (int*)&var;
  *ptr = 9999;
   cout << "var using ptr = " << *ptr << endl;
   cout << "var using var = " << var << endl;
   cout << "&var using ptr = " << ptr << endl;
   cout << "&var using var = " << &var << endl;
}
 

regards,
George

[weaknessforcats]

According to Stroustroup, using a const_cast is to change a variable is not guaranteed to work if the object was declared as const. That is, if the variable were originally non-const and was later to be accesses using a const pointer, you could const_cast the the const pointer to non-const and change the original object.

That is, a const_cast allows pointer acess to a variable but the result of using that pointer to change the value of the variable is undefined.

Did you not read this in my previous post???

Using a const_cast on a const object produces undefined results. That is, you can't say what will happen.

The whole point of a const_cast is when you have a const pointer to a non-const object and you wish to change the object. Here a const_cast can create a non-const pointer to the non-const object so you can change it.

I say again, casting in C++ will nearly always put you in a situation where you prpgram can crash. Casting in C++ usually means a) you care calling a relic C function that has a void* argument, or b) your C++ design is screwed up.

[George2]

Thanks for your advice, weaknessforcats!


I agree and my question is answered.

Did you not read this in my previous post???

Using a const_cast on a const object produces undefined results. That is, you can't say what will happen.

The whole point of a const_cast is when you have a const pointer to a non-const object and you wish to change the object. Here a const_cast can create a non-const pointer to the non-const object so you can change it.

I say again, casting in C++ will nearly always put you in a situation where you prpgram can crash. Casting in C++ usually means a) you care calling a relic C function that has a void* argument, or b) your C++ design is screwed up.

regards,
George