The deprecated conversion from string constant to 'char*'

[Eric]

I am working on a large, old code base and attempting to move it to
GCC 4.2. Throughout the code, there is stuff like:

char *aVar = "aString";

or

void aFunc( char *aVar) { ... }
aFunc( "aString" );

With this latest version of GCC, such code now generates the warning:

warning: deprecated conversion from string constant to 'char*'

and since I hate warnings, I am wondering what the best way to handle
this situation is.

There are, of course, some warnings which can safely be disabled and
ignored...is this one of them?
It doesn't seem to be based on the fact that it is 'deprecated' which
I interpret as meaning the ability to do this in the future will go
away.

Now, I can get rid of the warning by placing a (char*) in front of the
string (but not (const char*)...why?).
I can also get rid of the warning by changing the code to look like:

const char *aVar = "aString";
void aFunc( const char *aVar) { ... }

which seems to be a better solution.

Any thoughts, comments or suggestions?

 

[Matthias Berndt]

Use either const char* foo="bar"; or char foo[] = "bar";, depending on
whether you want to modify bar or not.

 

[Lars Tetzlaff]

I am working on a large, old code base and attempting to move it to
GCC 4.2. Throughout the code, there is stuff like:

char *aVar = "aString";

or

void aFunc( char *aVar) { ... }
aFunc( "aString" );

With this latest version of GCC, such code now generates the warning:

warning: deprecated conversion from string constant to 'char*'

and since I hate warnings, I am wondering what the best way to handle
this situation is.

There are, of course, some warnings which can safely be disabled and
ignored...is this one of them?
It doesn't seem to be based on the fact that it is 'deprecated' which
I interpret as meaning the ability to do this in the future will go
away.

Now, I can get rid of the warning by placing a (char*) in front of the
string (but not (const char*)...why?).
I can also get rid of the warning by changing the code to look like:

const char *aVar = "aString";
void aFunc( const char *aVar) { ... }

which seems to be a better solution.

Any thoughts, comments or suggestions?

#include <string>

const std::string aVar( "aString" );

void aFunc( const std::string& val ) { ... }


Don't use char* if you can use std::string. You will avoid many segfaults.


Lars

 

[sean_in_raleigh]

char *aVar = "aString";

void aFunc( char *aVar) { ... }
aFunc( "aString" );

It's important to realize *why* this is dangerous.

Consider:

void aFunc(char *s) { s[0] = 'X'; }
...
char *aVar = "aString";
char *aVar2 = "aString";
aFunc( aVar );
cout << aVar; // prints "XString"
cout << aVar2; // *also* prints "XString"

A compiler is completely free to only store a given
c-string literal in a single location (most do).
It's also free to store it in read-only memory.

Bottom line: modifying a string literal is
a bug, and requiring that pointers to string
literals are const is a compiler's only chance
of making sure you don't do it.

Sean

 

[Richard Herring]

In message

I am working on a large, old code base and attempting to move it to
GCC 4.2. Throughout the code, there is stuff like:

char *aVar = "aString";

or

void aFunc( char *aVar) { ... }
aFunc( "aString" );

With this latest version of GCC, such code now generates the warning:

warning: deprecated conversion from string constant to 'char*'

and since I hate warnings, I am wondering what the best way to handle
this situation is.

There are, of course, some warnings which can safely be disabled and
ignored...is this one of them?
It doesn't seem to be based on the fact that it is 'deprecated' which
I interpret as meaning the ability to do this in the future will go
away.

Now, I can get rid of the warning by placing a (char*) in front of the
string (but not (const char*)...why?).
I can also get rid of the warning by changing the code to look like:

const char *aVar = "aString";
void aFunc( const char *aVar) { ... }

which seems to be a better solution.

Any thoughts, comments or suggestions?

Definitely the latter. That way you are telling the compiler the truth,
which is that you don't wish to modify the thing pointed to. That's far
better than lying to it (or just saying that you know better), which is
usually what casting away constness amounts to.

 

[Gennaro Prota]

I am working on a large, old code base and attempting to move it to
GCC 4.2. Throughout the code, there is stuff like:

char *aVar = "aString";

or

void aFunc( char *aVar) { ... }
aFunc( "aString" );

With this latest version of GCC, such code now generates the warning:

warning: deprecated conversion from string constant to 'char*'

and since I hate warnings, I am wondering what the best way to handle
this situation is.

There are, of course, some warnings which can safely be disabled and
ignored...is this one of them?
It doesn't seem to be based on the fact that it is 'deprecated' which
I interpret as meaning the ability to do this in the future will go
away.

I'm not sure I parsed the above sentence correctly. It is deprecated
because it is unsafe, so the warning probably exists for both reasons


But it isn't going away: it's proliferating! The current working draft
has an analogous one for u/U-prefixed string literals.

Now, I can get rid of the warning by placing a (char*) in front of the
string (but not (const char*)...why?).

Because the conversion only exists from a string literal expression: if
the expression is (const char *) "abc", instead, it is not a string
literal, and has type const char *, which doesn't convert implicitly to
char *.

I can also get rid of the warning by changing the code to look like:

const char *aVar = "aString";
void aFunc( const char *aVar) { ... }

which seems to be a better solution.

I'd recommend the modification, yes (a common problem when working with
old code is that, for various reasons, you cannot modify it. But you
can, so... be happy )

In the latter example, above, I'd write

const char aVar[] = "aString" ;

but that's a minor issue.

 

[Eric]

I'm not sure I parsed the above sentence correctly. It is deprecated
because it is unsafe, so the warning probably exists for both reasons


But it isn't going away: it's proliferating! The current working draft
has an analogous one for u/U-prefixed string literals.

Well, that would appear to be bad...