Does casting a string as char pointer automatically allocate required memory in C/C++?

Question

So while playing with codes I discovered a new technique of assigning pointer values without allocating memory previously.

####################

#include <stdio.h>

int main(){

char* name;

name =(char*) "String Sample";

return 0;

}

#######################

The code above works well without explicitly allocating required memory (using mallocs or new keywords) and neither does it throw any error or warning... So does this mean that the (char*) casting of the string automatically allocate the required memory space for the string?

And is this method safe to use and recommended for a bigger scale application?

This method can be useful when the actual size for allocating a string isn't known...

Thanks....

Edit:

Fixed a small mistake of casting the lvalue instead the string right hand side.

Answer 1

This is a standard technique. You are assigning name to point to "String Sample", which is a constant string literal. It has a type, which is already (char *), so there is no need to explicitly cast it. Since the string is a const, you may not alter any characters. So, for instance *name = 's'; would fail. But it is perfectly valid to read any element of the string (e.g., putc(name[7]);) or print the whole string (puts(name);) without causing memory violation. Its memory is preallocated and loaded as the program loads into memory. You may also freely reassign name to point to another string as needed.

Answer 2

Brian I have just noticed I misuderstood the 4th line:
name = (char*) "String Sample";
I read this as writing the string to the pointer (arbitrary) address. In fact, it writes the string address to the pointer, effectively initializing it.
So the memory range is used by the string itself, and the code is safe.

Thanks for calling my attention on that. [B.S.] BITTU , pls see this correction.

Answer 3

Emerson Prado thank you for clearing that up. ✌️ I was getting confused by your responses! 💁‍♂️

Answer 4

Emerson Prado How does it successfully write when the pointer literally points toward nothing? It should have given a warning, shouldn't have it?

Answer 5

[B.S.] BITTU A pointer always points somewhere. It's a variable, so it always has a value.
The real issue is that this value is unknown and points to an arbitrary address that can be in use by something else. If your process can write there, it will. Then ruin this something else.

Answer 6

Brian In fact, the question mentions writing the addresses. What happens if this write works, and the addresses are in use?

Answer 7

Emerson Prado did I miss part of the question? I don't see where the OP asks about writing to an uninitialized pointer address.

Answer 8

Emerson Prado I am getting a bit confused. So let's jump to the conclusion directly , this code is safe then alright?

And I hope this code will not interfere somewhere else by creating bugs in my code which is gonna be large application which includes many complex techniques.

and last question...

can I use free() in this non explicitly allocated block?

Answer 9

[B.S.] BITTU Yes, it's safe, won't create bugs.
I tried in Code Playground, and free complained on "Invalid pointer". I don't know if it depends on implementation. Maybe we could try in a couple other compilers.

Answer 10

Well, tried in tio.run and gcc 8.3.0, with the same results

Answer 11

Emerson Prado hm... Okay 👍

Answer 12

Not sure, but probably this does not allocate any memory - just writes wherever the pointer points to, which is highly unsafe.