How would one modify a constant string?

Question

To create a string that I can modify, I can do something like this:

// Creates a variable string via array
char string2[] = "Hello";
string2[0] = 'a'; // this is ok

And to create a constant string that cannot be modified:

// Creates a constant string via a pointer
char *string1 = "Hello";
string1[0] = 'a'; // This will give a bus error

My question then is how would one modify a constant string (for example, by casting)? And, is that considered bad practice, or is it something that is commonly done in C programming?

Answer 1

By definition, you cannot modify a constant. If you want to get the same effect, make a non-constant copy of the constant and modify that.

Answer 2

You cannot modify the contents of a string literal in a safe or reliable manner in C; it results in undefined behavior. From the C11 standard draft section 6.4.5 p7 concerning string literals:

It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.

Answer 3

how would one modify a constant string (for example, by casting)?

If by this you mean, how would one attempt to modify it, you don't even need a cast. Your sample code was:

char *string1 = "Hello";
string1[0] = 'a';         // This will give a bus error

If I compile and run it, I get a bus error, as expected, and just like you did. But if I compile with -fwritable-strings, which causes the compiler to put string constants in read/write memory, it works just fine.

I suspect you were thinking of a slightly different case. If you write

const char *string1 = "Hello";
string1[0] = 'a';         // This will give a compilation error

the situation changes: you can't even compile the code. You don't get a Bus Error at run-time, you get a fatal error along the lines of "read-only variable is not assignable" at compile time.

Having written the code this way, one can attempt to get around the const-ness with an explicit cast:

((char *)string1)[0] = 'a';

Now the code compiles, and we're back to getting a Bus Error. (Or, with -fwritable-strings, it works again.)

is that considered bad practice, or is it something that is commonly done in C programming

I would say it is considered bad practice, and it is not something that is commonly done.

I'm still not sure quite what you're asking, though, or if I've answered your question. There's often confusion in this area, because there are typically two different kinds of "constness" that we're worried about:

1. whether an object is stored in read-only memory

2. whether a variable is not supposed to be modified, due to the constraints of a program's architecture

The first of these is enforced by the OS and by the MMU hardware. It doesn't matter what programming-language constructs you did or didn't use -- if you attempt to write to a readonly location, it's going to fail.

The second of these has everything to do with software engineering and programming style. If a piece of code promises not to modify something, that promise may let you make useful guarantees about the rest of the program. For example, the strlen function promises not to modify the string you hand it; all it does is inspect the string in order to compute its length.

Confusingly, in C at least, the const keyword has mostly to do with the second category. When you declare something as const, it doesn't necessarily (and in fact generally does not) cause the compiler to put the something into read-only memory. All it does is let the compiler give you warnings and errors if you break your promise -- if you accidentally attempt to modify something that elsewhere you declared as const. (And because it's a compile-time thing, you can also readily "cheat" and turn off this kind of constness with a cast.)

But there is read-only memory, and these days, compilers typically do put string constants there, even though (equally confusingly, but for historical reasons) string constants do not have the type const char [] in C. But since read-only memory is a hardware thing, you can't "turn it off" with a cast.

Answer 4

Attempting to modify constant string literal is undefined behavior. You may get a bus error, as in your case, or the program may not even indicate that the write failed at all. This is undefined behavior for you - the language makes no promises at this point.

You could reassign the pointer (losing your reference to the string "Hello"):

char *s1 = "Hello";
printf("%s ", s1);
s1 = "World";
printf("%s\n", s1);