Pointers create constant string literals, why?

Question

I was going through some documentation which states that

First Case

char * p_var="Sack";     

will create a constant string literal.

And hence code like

  p_var[1]="u";             

will fail because of that property.

Second Case

Also mentioned is that this is possible only for character literals and not for other data types through pointers. So code like

float *p="3.14"; 

will fail, resulting in a compiler error.

But when i try it out i don't get compiler errors ,accessing it though gives me 0.000000f(using gcc on Ubuntu).

So regarding the above, i have three queries:

1. Why are string literals created in First Case read-only?

2. Why are only string literals allowed to be created and not other constants like float through pointers?

3. Why is Second Case not giving me compiler errors?

Update

Please discard the 3rd question and second case. I tested it by adding quotes.

Thanks

Answer 1

Regarding your question:

• Why are string literals created in First Case read-only?

char *p_var="Sack";

Well, the p_var is assigned with the starting address of the memory allocated to the string "Sack". p_var content is not read-only, since you haven't put the const keyword anywhere in C constructs. Although manipulating the p_var contents like strcpy or strcat may cause undefined behavior.

Quote C ISO 9899:

The declaration
char s[] = "abc", t[3] = "abc";
defines plain char array objects s and t whose elements are initialized with character string literals.
This declaration is identical to:
char s[] = { 'a', 'b', 'c', '\0' }, t[] = { 'a', 'b', 'c' };
The contents of the arrays are modifiable. On the other hand, the declaration:
char *p = "abc";
defines p with type pointer to char and initializes it to point to an object with type array of char with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is undefined.

An explanation of why it could be read-only per your platform and compiler:

Commonly string literals will be put in "read-only-data" section which gets mapped into the process space as read-only (which is why you seem to not being allowed to change it).

But some platforms do allow, the data segment to be writable.

• Why are only string literals allowed to be created and not other constants like float? and the third question.

To create a float constant you should use: const float f=1.5f;

Now, when you are doing: float *p="3.14"; you are basically assigning the string literal's address to a float pointer.

Try compiling with -Wall -Werror -Wextra. You will find out what is happening. It works because, in practice, there's no difference between a char * and a float * under the hood.

Its as if you are writing this:
float *p=(float*) "3.14";

This is a well-defined behaviour, unless the memory alignment requirements of float and char differ, in which case it results in undefined behaviour (Reference: C99, 6.3.2.3 p7).

Answer 2

float *p="3.14"; 

This is also a string literal !

  Why are string literals created in First Case read-only?

No, both "sack" and "3.14" are string literals and both are read-only.

---

Why are only string literals allowed to be created and not other constants like float?

If you want to create a float const then do:

const float p=3.14;

---

Why is Second Case not giving me compiler errors? 

You are making the pointer p point to a string literal. When you dereference p, it expects to read a float value. So there's nothing wrong as far as the compiler can see.

Answer 3

The premise is wrong: pointers don’t create any string literals, neither read-only nor writeable.

What does create a read-only string literal is the literal itself: "foo" is a read-only string literal. And if you assign it to a pointer, then that pointer points to a read-only memory location.

With that, let’s turn to your questions:

Why are string literals created in First Case read-only?

The real question is: why not? In most cases, you won’t want to change the value of a string literal later on so the default assumption makes sense. Furthermore, you can create writeable strings in C via other means.

Why are only string literals allowed to be created and not other constants like float?

Again, wrong assumption. You can create other constants:

float f = 1.23f;

Here, the 1.23f literal is read-only. You can also assign it to a constant variable:

const float f = 1.23f; 

Why is Second Case not giving me compiler errors?

Because the compiler cannot check in general whether your pointer points to read-only memory or to writeable memory. Consider this:

char* p = "Hello";
char str[] = "world"; // `str` is a writeable string!

p = &str[0];

p[1] = 'x';

Here, p[1] = 'x' is entirely legal – if we hadn’t re-assigned p beforehand, it would have been illegal. Checking this cannot be generally done at compile-time.

Answer 4

1. Efficiency
2. they are
3. It's a string mind the quotes