为什么C中的字符串用'const'声明？

Question

For example, why not:

char *s= "example";

instead of:

const char *s= "example";

I understand that const makes it unchangeable, but why do I receive an error when compiling the first?

Additionally, how does the concept apply to

int * x;

vs

const int *x;

I see the second used a lot more, is it good practice to use "cons int *"?

Answer 1

There's no requirement to use const , but it's a good idea.

In C, a string literal is an expression of type char[N] , where N is the length of the string plus 1 (for the terminating '\\0' null character). But attempting to modify the array that corresponds to the string literal has undefined behavior. Many compilers arrange for that array to be stored in read-only memory (not physical ROM, but memory that's marked read-only by the operating system). (An array expression is, in most contexts converted to a pointer expression referring to the initial element of the array object.)

It would have made more sense to make string literals const , but the const keyword did not exist in old versions of C, and it would have broken existing code. (C++ did make string literals const ).

This:

char *s= "example"; /* not recommended */

is actually perfectly valid in C, but it's potentially dangerous. If, after this declaration, you do:

s[0] = 'E';

then you're attempting to modify the string literal, and the behavior is undefined.

This:

const char *s= "example"; /* recommended */

is also valid; the char* value that results from evaluating the string literal is safely and quietly converted to const char* . And it's generally better than the first version because it lets the compiler warn you if you attempt to modify the string literal (it's better to catch errors at compile time than at run time).

If you get an error on your first example, then it's likely that you're inadvertently compiling your code as C++ rather than as C -- or that you're using gcc's -Wwrite-strings option or something similar. ( -Wwrite-strings makes string literals const ; it can improve safety, but it can also cause gcc to reject, or at least warn about, valid C code.)

Answer 2

With Visual Studio 2015 at warning level 4, this compiles and runs whether compiled as C or C++:

#include <stdio.h>

char *s1= "example\n";
const char *s2= "example\n";

int main(int argc, char **argv)
{
    printf(s1);  // prints "example"
    s1[2] = 'x';
    printf(s1);  // prints "exxmple"

    printf(s2);

    return 0;
}

If I add this line, it will fail to compile as C or C++ with every compiler I know of:

    s2[2] = 'x'; // produces compile error

This is the error the const keyword is designed to avoid. It simply tells the compiler not to allow assignments to the object pointed to.

It doesn't matter if your pointer points to char or int or anything else. The const keyword has the same effect on all pointers, and that's to make it impossible (well, very hard) to assign to the thing declared const .

Answer 3

A string literal used as a value compiles to an array of char that should not be modified. Attempting to modify it invokes undefined behavior. For historical reasons of backward compatibility, its type is char [] although is really should be const char [] . You can enable extra compiler warnings to change this and instruct the compiler to consider such strings to be const .