This article was previously published under Q87020
This article has been archived. It is offered "as is" and will no longer be updated.
The Microsoft compilers listed above, in accordance withrestrictions defined by the Annotated Reference Manual (ARM) and laterX3J16 working papers, will prevent type conversions that would potentiallyallow the modification of data qualified as type "const". An example ofthis is as follows:
int I = 8;int * pI = &I;const int cI = 11;const int * pcI = &cI;const int ** ppcI = &pcI;ppcI = &pI; // This should not be allowed because later attempts // to perform the assignment "*pI = 0;" would // modify the value "**ppcI" that was declared as // being constant.
If the code above is compiled using C/C++ version 7.0, the followingtwo errors will be generated:
error C2446: '=' : no conversion between 'const int __near * __near * ' and 'int __near *__near * '
error C2664: 'f_ppci' : cannot convert parameter 1 from 'int __near *__near * ' to 'const int __near *__near * '
If this same code is compiled using Visual C++ version 4.0, the followingerror will be generated:
error C2446: '=' : no conversion from 'int ** ' to 'const int ** ' (new behavior; please see help)
If this same code is compiled using Visual C++ version 5.0, the followingerror will be generated:
error C2440: '=' : cannot convert from 'int ** ' to 'const int ** ' Conversion loses qualifiers
The Microsoft C/C++ compiler is correctly generating the errors.According to the ANSI committee for C++, the compiler should producean error.
There are eight legal conversions allowed by C++ (see ARM section 13.2page 3), two of which are applicable to this example (if T representsa type):
T --> T const (or const T) T* --> T const * (or const T *)
Using the T symbol, the example given above (ppcI = &pI) could beexpressed as follows:
T** --> const T**
To demonstrate why this conversion is not legal, substitute for T inthe rules given earlier and show that the conversion "T** --> constT**" cannot be derived from those two rules:
Let "int**" be T. By the first rule, then, the following is possible: int** --> int** const
You might immediately assume that because "T const" is the same as"const T", then "int** const" is the same as "const int**", but thisis not true. The "const" keyword modifies whatever falls directly tothe right of it. For example:
const int* D; // "int" is to the right of "const," so D is a // pointer to a constant integer. The compiler // will protect the value of *Dint* const D; // D is to the right of "const" and D is a // pointer, so D would be called a "constant pointer // to an integer." The compiler will allow you to // modify *D, but not D itself.const int D; // These two are identical.int const D;
Hence, the first legal conversion (T --> T const) does not apply tothis example.
Try the second rule, and let 'int*' be T, which gives you:
'int*'* --> 'int*' const *
The type "int* const *" can be translated as "a constant pointer to apointer that points to an integer." The target is "a pointer to apointer that points to a constant integer." So the second legalconversion is also not applicable to this example. With this, it isapparent that there is no legal combination of rules that will allowthe conversion "T** --> const T**" to be made.