Why can I have a const char pointer point to a mutable char array?

Question

Why is this fine:

char a[2];
a[0]='a';
const char* b;
b=a;
printf("%s\n",b);
a[0]='b';
printf("%s",b);

why can a pointer to a constant string point to a non constant string? Also how do string constants work when assigning them to variables? Why can you do this:

const char* b="hello";
b="test";

or

char* b="hello";
b="test";

but you can only do the first line if it is an array? constant or not?

Answer 1

Why can I have a const char * point to a mutable char array?

The const here with b puts a restriction on its use. It is not allowing some new usage, but potentially less. So no opening of Pandora's Box here.

char a[2];
const char* b = a;

b has read-access to the array. The array a[] may still change via a.

a[0]='y'; // OK
b[0]='z'; // leads to error like "error: assignment of read-only location "

Also how do string constants work when assigning them to variables? constant or not?

"hello" is a string literal of type char [6]. With const char* b1 = "hello" declaration and initialization, b1 is assigned a pointer of type char *. This could have been const char *, yet for historical reasons¹ it is char *. Since it is char*, char* b2 = "hello"; is also OK.

const char* b1 = "hello";
char* b2 = "hello";

Also how do string constants work when assigning them to variables?

b="test";

As part of the assignment, the string literal, a char array, is converted to the address and type of its first element, a char *. That pointer is assigned to b.

---

¹ const was not available in early C, so to not break existing code bases, string literals remained without a const.

Answer 2

You can always add const-ness to a type. This is a good thing, because it allows you to write functions that make some guarantees.

//Here we know *str is const, so the function will not change what's being pointed to.
int strlength(const char *str) {
    int length = 0;
    while (*str++)
        ++length;
    return length;
}

int main(void) {
    char a[2] = "a"; //a[0] and a[1] are mutable in main(), but not in strlength().
    printf("%d", strlength(a));
}

Note that casting away const-ness leads to undefined behavior:

void capitalize(char *str) {
    if (isalpha(*str))
        *str = toupper(*str);
}

int main(void) {
    const char *b = "hello";
    capitalize((char*) b); //undefined behavior. Note: without the cast, this may not compile.
}

As for your second question, your first example is correct because the type of a string literal in C (i.e. any sequence of characters between double quotes) is of type const char*. This is valid:

const char *b = "hello"; //"hello" is of type const char*
b = "text"; //"text" is of type const char*

Because casting away const leads to undefined behavior, this code is invalid:

char *b = "hello"; //undefined behavior; "hello" is const char*
b = "text"; //undefined behavior; "text" is const char*

The case for arrays is a little more involved. When used in expressions, arrays act as pointers, but arrays are a fundamentally different type than pointers:

char a[10];
a = "hello"; //does not compile - "hello" is a const char*; a is a char[10]

However, when used in an initialization statement, the rules state that a const char* can be used to initialize a character array:

char a[10] = "hello"; //initialization - a is a char[10], "hello" is a const char*
                      //a will contain {'h','e','l','l','o',0,0,0,0,0}

Also, don't forget that you can assign a string literal to an array with strcpy:

char a[10];
strcpy(a, "hello");
assert(strcmp(a, "hello") == 0);
//a will contain {'h','e','l','l','o',0,x,x,x,x}
//here x's mean uninitialized