converting a char* to a const char*

[Sean Farrow]

Hi:
What is best and safest way of converting a char* to a const char *? Can I
use const_cast?
Cheers
Sean.

[Pete Becker]

On 2008-08-06 19:28:36 -0400, Juha Nieminen <no****@thanks. invalidsaid:

James Kanze wrote:

>>You have got it backwards: const_cast is used to *remove*
constness, not to add it.

Usually. It can be used either way, and there are times when
you want to explicitly add the const, to control overload
resolution, or template instantiation, for example.

Isn't that what static_cast is for? const_cast sounds like the wrong
tool for the job (because common C++ wisdom dictates that static_cast is
good and const_cast should usually be avoided if possible).

This overlooks another overbroad principle: const_cast should be used
to adjust constness; using other casts for that purpose should be
avoided.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[James Kanze]

On Aug 7, 1:28 am, Juha Nieminen <nos...@thanks. invalidwrote:

James Kanze wrote:

You have got it backwards: const_cast is used to *remove*
constness, not to add it.

Usually. It can be used either way, and there are times when
you want to explicitly add the const, to control overload
resolution, or template instantiation, for example.

Isn't that what static_cast is for? const_cast sounds like the
wrong tool for the job (because common C++ wisdom dictates
that static_cast is good and const_cast should usually be
avoided if possible).

That's a good point. As Pete said, const_cast is for adjusting
const, and that's what you're doing. But IMHO, it's arguable
both ways:

-- If you use static_cast, you can't accidentally add const
(but is this really a problem?). Also, it won't show up if
someone greps for const_cast (which they're doubtlessly
doing to find "dangerous" code, and adding const isn't
dangerous).

-- If you use const_cast, you can't accidentally perform a
Derived* to Base* (or worse, a Base* to Derived*) conversion
which you didn't want.

IMHO, that second point predominates, and is, ultimately, the
reason why the new style casts were introduced: const_cast
allows adjusting const-ness, with no risk of accidentally
performing any other conversion, static_cast allows moving up
and down in the hierarchy, without any risk of accidentally
removing const-ness or type punning, and reinterpret_cas t forces
type punning (even if the types involved are pointers within an
inheritance hierarchy), without any risk of removing const-ness.

You may as well say "if you want to add constness eg. for
overload resolution, use reinterpret_cas t". That's just wrong.

Agreed. Using static_cast or reinterpret_cas t to adjust
const-ness, even when they allow it (i.e. adding const) is just
wrong.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[anon]

Pete Becker wrote:

On 2008-08-06 14:19:43 -0400, kwikius <an**@servocomm .freeserve.co.u k>
said:

>>
Problem is that const_cast sometimes looks like a nice easy solution
to problems, which it isnt.

Agreed. It's an advanced feature, and beginners shouldn't use it.

Do you have a link to good article explaining const_cast, cause I never
read anything similar.

I am asking, because in my application is like this:

int main( const int argc, const char* argv[] )
{
....

int arg1 = argc;
char** arg2 = const_cast< char** ( &argv[0] );
glutInit( &arg1, arg2 );
....
}

glutInit function is described here:
http://www.opengl.org/documentation/...c3/node10.html

Am I doing something not allowed? If so, how to fix?

[Pete Becker]

On 2008-08-07 04:14:03 -0400, James Kanze <ja*********@gm ail.comsaid:

>
-- If you use static_cast, you can't accidentally add const

But you can. <gThe prohibition is that "The static_cast operator
shall not cast away constness...". [expr.static.cas t]/1.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Pete Becker]

On 2008-08-07 04:43:44 -0400, anon <an**@no.nosaid :

Pete Becker wrote:

>On 2008-08-06 14:19:43 -0400, kwikius <an**@servocomm .freeserve.co.u ksaid:

>>>
Problem is that const_cast sometimes looks like a nice easy solution
to problems, which it isnt.

Agreed. It's an advanced feature, and beginners shouldn't use it.

Do you have a link to good article explaining const_cast, cause I never
read anything similar.

I am asking, because in my application is like this:

int main( const int argc, const char* argv[] )

Why? "char *argv[]" is the usual form.

{
...

int arg1 = argc;
char** arg2 = const_cast< char** ( &argv[0] );
glutInit( &arg1, arg2 );
...
}

glutInit function is described here:
http://www.opengl.org/documentation/...c3/node10.html

Am I doing something not allowed? If so, how to fix?

No, it's allowed. But it's contradictory: the declaration of main says
that the chars in the argument array are not modifiable, then later on
the cast says that they are. Make up your mind.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Juha Nieminen]

James Kanze wrote:

>You may as well say "if you want to add constness eg. for
overload resolution, use reinterpret_cas t". That's just wrong.

Agreed. Using static_cast or reinterpret_cas t to adjust
const-ness, even when they allow it (i.e. adding const) is just
wrong.

Intentionally misinterpreting someone's text, even if it's clearly a
pun, is annoying.

[Greg Comeau]

In article <g7**********@n ews01.versatel. de>, anon <an**@no.nowrot e:

>Pete Becker wrote:

>On 2008-08-06 14:19:43 -0400, kwikius <an**@servocomm .freeserve.co.u k>
said:

>>Problem is that const_cast sometimes looks like a nice easy solution
to problems, which it isnt.

Agreed. It's an advanced feature, and beginners shouldn't use it.

Do you have a link to good article explaining const_cast, cause I never
read anything similar.

I am asking, because in my application is like this:

int main( const int argc, const char* argv[] )
{
...

int arg1 = argc;
char** arg2 = const_cast< char** ( &argv[0] );
glutInit( &arg1, arg2 );
...
}

This is well somewhat confusing, though useful :) as main normally
doesn't take arguments declared that way. In specific, argc and argv
and *argv and **argv etc are all modifiable. So if the const_cast
was added because of that mistake, then the const_cast is a mistake.
Which, once again points to the dangers of casting, adding cast to
get around errors, etc. Now, assuming this was some other function
and not main and assuming the arguments are of those type, then yes,
a const_cast<like that might make sense.

BTW, there is also a side issue about declaring argc const.
The usual argument is that a top level const parameter does not lend
to the interface of function, therefore, it should not be there.
I'm not saying one is right and one is wrong (though others here
might :} ), just putting the issue on the table as you will no doubt
eventually run across it.
--
Greg Comeau / 4.3.10.1 with C++0xisms now in beta!
Comeau C/C++ ONLINE == http://www.comeaucomputing.com/tryitout
World Class Compilers: Breathtaking C++, Amazing C99, Fabulous C90.
Comeau C/C++ with Dinkumware's Libraries... Have you tried it?

[James Kanze]

On Aug 7, 10:43 am, anon <[e-mail] e:

Pete Becker wrote:

On 2008-08-06 14:19:43 -0400, kwikius <a...@servocomm .freeserve.co.u k>
said:

Problem is that const_cast sometimes looks like a nice easy
solution to problems, which it isnt.

Agreed. It's an advanced feature, and beginners shouldn't use it.

Do you have a link to good article explaining const_cast,
cause I never read anything similar.

I am asking, because in my application is like this:

int main( const int argc, const char* argv[] )
{
...
int arg1 = argc;
char** arg2 = const_cast< char** ( &argv[0] );
glutInit( &arg1, arg2 );
...
}

glutInit function is described here:http://www.opengl.org/documentation/...c3/node10.html

Am I doing something not allowed? If so, how to fix?

Yes. That's not a standard definition of main. The two
standard definitions are:
int main()
and
int main( int argc, char** argv )
Anything else is an implementation extension, if it works at
all.

I wonder: why don't compilers complain about versions of main
they don't support? I just compiled a
int main( double d ){}
, and none of the compilers I use even output a warning.
Although I'm pretty sure that if I tried to use the d, I'd just
get garbage. The behavior in such cases is implementation
defined; there's no reason for an implementation to not generate
an error if it doesn't support the definition. (IMHO, this
would be far more useful than forbidding "void main()", despite
the fact that it more or less works.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Aug 7, 5:42 pm, [e-mail] m (Greg Comeau) wrote:

This is well somewhat confusing, though useful :) as main
normally doesn't take arguments declared that way. In
specific, argc and argv and *argv and **argv etc are all
modifiable.

Is this an intentional change from C, or something that just
slipped through. (In C, the type of argv is char**, but the
application isn't allowed to modify the pointers in the array
pointed to by argv---although it is allowed to modify argv
itself, and the strings the pointers point to: "argv=p" is
legal, as is "argv[1][0]='\0' (provided that argc >= 2), but not
"argv[1]=p".)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Aug 7, 12:19 pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-08-07 04:14:03 -0400, James Kanze <james.ka...@gm ail.comsaid:

-- If you use static_cast, you can't accidentally add const

But you can. <gThe prohibition is that "The static_cast operator
shall not cast away constness...". [expr.static.cas t]/1.

That's a typo. I meant to say that you can't accidentally
remove const.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]