«

Gianni Mariani a écrit :
> Noah Roberts wrote:
>> Gianni Mariani wrote:
> ...
>>
>> It always intrigues me that such distinction is made in cases like this
>> yet this is perfectly ok from a legal point of view:
>>
>> char * x = "I'm const";
>
> Yes, sigh. I think the standard's commitee made a blunder on that one.
>
> This is due to a rather short sighted view that there was a large legacy
> code base that would break if that was not allowed. At a guess, I think
> this would not be in the standard as an exception if hindsight was
> available.

The standard comitee didn't want to constraint compilers with putting
the array in a rw area.
The compiler is free to put in ro and save some copy time. The array can
even be shared among other part of the program.

That is a reason why casting away the consteness is undefined in this
case and should not be done.

Michael

Michael DOUBEZ wrote:

> Gianni Mariani a écrit :
>> Noah Roberts wrote:
>>> Gianni Mariani wrote:
>> ...
>>>
>>> It always intrigues me that such distinction is made in cases like this
>>> yet this is perfectly ok from a legal point of view:
>>>
>>> char * x = "I'm const";
>>
>> Yes, sigh. I think the standard's commitee made a blunder on that one.
>>
>> This is due to a rather short sighted view that there was a large legacy
>> code base that would break if that was not allowed. At a guess, I think
>> this would not be in the standard as an exception if hindsight was
>> available.
>
> The standard comitee didn't want to constraint compilers with putting
> the array in a rw area.
> The compiler is free to put in ro and save some copy time. The array can
> even be shared among other part of the program.

What does this have to do with the choice to allow letting a pointer to
non-const point to string literals without a cast?

> That is a reason why casting away the consteness is undefined in this
> case and should not be done.

Casting away constness isn't undefined. Only writing to an object that was
initially declared const is.

Michael DOUBEZ a écrit :
> Gianni Mariani a écrit :
>> Noah Roberts wrote:
>>> Gianni Mariani wrote:
>> ...
>>>
>>> It always intrigues me that such distinction is made in cases like this
>>> yet this is perfectly ok from a legal point of view:
>>>
>>> char * x = "I'm const";
>>
>> Yes, sigh. I think the standard's commitee made a blunder on that one.
>>
>> This is due to a rather short sighted view that there was a large
>> legacy code base that would break if that was not allowed. At a
>> guess, I think this would not be in the standard as an exception if
>> hindsight was available.
>
> The standard comitee didn't want to constraint compilers with putting
> the array in a rw area.
> The compiler is free to put in ro and save some copy time. The array can
> even be shared among other part of the program.
>
> That is a reason why casting away the consteness is undefined in this
> case and should not be done.

In fact, it is legacy code that allowed this writing because string use
to be defaulted as char[] and automaticaly casted to char*.
And the standard changed the type of string to const char[] and thus
strings can now only be automatically casted into const char*.

Michael

Rolf Magnus a écrit :
> Michael DOUBEZ wrote:
>
>> The standard comitee didn't want to constraint compilers with putting
>> the array in a rw area.
>> The compiler is free to put in ro and save some copy time. The array can
>> even be shared among other part of the program.
>
> What does this have to do with the choice to allow letting a pointer to
> non-const point to string literals without a cast?

Why would you be allowed to cast it to not const if not to be able to
modify it ?
And if it is done automatically, there is the risk you modify the string
without remebering it is const.

>
>> That is a reason why casting away the consteness is undefined in this
>> case and should not be done.
>
> Casting away constness isn't undefined. Only writing to an object that was
> initially declared const is.
>

Yes, writing is undefined; that is what I meant.

Michael

"Grizlyk" <> wrote in news:epkdp5$emk$:

> Gianni Mariani wrote:
>>>
>>> unsigned char * p = reinterpret_cast<unsigned char *>("abcdg");
>>>
>>> the compiler tells me that "reinterpret_cast from type "const char *
>>> " to type "unsigned char *" casts away constness "
>>
>> The compiler is right. "unsigned char *" is non-const and string
>> literals (like "abcdg") are const.
>>
>>
>> If you're casting to a "unsigned char *" you need to ask yourself
>> why.
>
> I think, the following expression
> unsigned char * p = static_cast<unsigned char *>(
> const_cast<char*>
> ("abcdg") );
> is not work because sizeof("type") can be not equal to
> sizeof("unsigned type") in theory,

So? That code is casting pointers-to-object. The pointer size won't
change, regardless of the size of the pointed to object.

Andre Kostur wrote:
>> I think, the following expression
>> unsigned char * p =
>> static_cast<unsigned char *>
>> (
>> const_cast<char*>("abcdg")
>> );
>> is do not work because sizeof("type") can be not equal
>> to sizeof("unsigned type") in theory
>
> So? That code is casting pointers-to-object. The pointer size won't
> change, regardless of the size of the pointed to object.

I am not shure (i have no standard) that pointers for all types must have
fixed sizeof() (as "int" for example) or unsigned type must have the same
sizeof() as signed type.

For example there are memory models, where "sizeof(char *_far)==4", but
"sizeof(char *)==2".

Let pointers have fixed sizeof() and sizeof("type")!=sizeof("unsigned
type"). Here pointer arithmetic can be changed, because value of next
pointer (++ptr) is depending from size of object pointer point to.

For example:

int *i=0;
++i; //value of i is 4

char *c=0;
++c; //value of c is 1

//assuming sizeof(int)!=sizeof(unsigned)
unsigned *u=0;
++u; //value of u is 8

--
Maksim A Polyanin

"Grizlyk" <> wrote in news:epl9fa$f00$:

> Andre Kostur wrote:
>>> I think, the following expression
>>> unsigned char * p =
>>> static_cast<unsigned char *>
>>> (
>>> const_cast<char*>("abcdg")
>>> );
>>> is do not work because sizeof("type") can be not equal
>>> to sizeof("unsigned type") in theory
>>
>> So? That code is casting pointers-to-object. The pointer size won't
>> change, regardless of the size of the pointed to object.
>
> I am not shure (i have no standard) that pointers for all types must
> have fixed sizeof() (as "int" for example) or unsigned type must have
> the same sizeof() as signed type.
>
> For example there are memory models, where "sizeof(char *_far)==4",
> but "sizeof(char *)==2".

sizeof(char * _far) is a non-standard type, and thus is implementation-
dependant. All Standard pointers-to-object have the same size.

> Let pointers have fixed sizeof() and sizeof("type")!=sizeof("unsigned
> type"). Here pointer arithmetic can be changed, because value of next
> pointer (++ptr) is depending from size of object pointer point to.

Pointer arithmetic has nothing to do with sizeof(T*). But is related to
sizeof(T).

Michael DOUBEZ wrote:
> Rolf Magnus a écrit :
>> Michael DOUBEZ wrote:
>>
>>> The standard comitee didn't want to constraint compilers with putting
>>> the array in a rw area.
>>> The compiler is free to put in ro and save some copy time. The array can
>>> even be shared among other part of the program.
>>
>> What does this have to do with the choice to allow letting a pointer to
>> non-const point to string literals without a cast?
>
> Why would you be allowed to cast it to not const if not to be able to
> modify it ?
> And if it is done automatically, there is the risk you modify the string
> without remebering it is const.

I think you've missed the point. The compiler will not complain about
code that does this:

char * x = "hello";
x[2] = 't';

You'll only get a warning when you try to run the program...if
then...maybe only when you create your release compile with its
optimizations...maybe a customer will find it.

The standard requires that this is ok. It is undefined, even in C where
it comes from, but there can be no diagnostic. Most people would like
to get the usual error about attempting to assign const to non-const
without a cast, but you don't get that in this one special case. Allows
for all sorts of unfortunate errors.

In article <epkdp5$emk$>, "Grizlyk" <>
wrote:

> Gianni Mariani wrote:
> >>
> >> unsigned char * p = reinterpret_cast<unsigned char *>("abcdg");
> >>
> >> the compiler tells me that "reinterpret_cast from type "const char * " to
> >> type "unsigned char *" casts away constness "
> >
> > The compiler is right. "unsigned char *" is non-const and string literals
> > (like "abcdg") are const.
> >
> >
> > If you're casting to a "unsigned char *" you need to ask yourself why.
>
> I think, the following expression
> unsigned char * p = static_cast<unsigned char *>( const_cast<char*>
> ("abcdg") );
> is not work because sizeof("type") can be not equal to sizeof("unsigned
> type") in theory,

AFAIK, the above is incorrect. sizeof( "unsigned type" ) always equals
sizeof( "type" )

Andre Kostur wrote:

> "Grizlyk" <> wrote in news:epkdp5$emk$:
>
>> Gianni Mariani wrote:
>>>>
>>>> unsigned char * p = reinterpret_cast<unsigned char *>("abcdg");
>>>>
>>>> the compiler tells me that "reinterpret_cast from type "const char *
>>>> " to type "unsigned char *" casts away constness "
>>>
>>> The compiler is right. "unsigned char *" is non-const and string
>>> literals (like "abcdg") are const.
>>>
>>>
>>> If you're casting to a "unsigned char *" you need to ask yourself
>>> why.
>>
>> I think, the following expression
>> unsigned char * p = static_cast<unsigned char *>(
>> const_cast<char*>
>> ("abcdg") );
>> is not work because sizeof("type") can be not equal to
>> sizeof("unsigned type") in theory,
>
> So? That code is casting pointers-to-object. The pointer size won't
> change, regardless of the size of the pointed to object.

Well, but using a pointer for accessing an object of a size different from
the pointed-to type might lead to trouble if you aren't prepared for it.

Btw: Different pointer types might also have different sizes.