char pointer initialization compared to non pointer? What happens

Question

I know you cant do this with a normal char.

    char line1 = "hello";

but you can do this with a pointer to a char type

    char* line2 = "hello";

I wanted to know why this is, what happens in the second line of code? Why is the second initialization possible? Is line2 pointing to the first index of hello? does it create some kind of array and fill it in with hello? I used this in a c string class for a programming class and I am still confused about what goes on in the second line of code.

Answer 1

The compiler ensures that the null-terminated string"hello" you specified exists somewhere in memory, and initializes the pointer to point to the beginning of that string.

Answer 2

When you write

char *line1 = "something";

line1 is created as a pointer on the stack (if in the automatic scope) and gets initialized to point to the literal string "something" (with a null terminator). To be precise the "something" string has type char[10] including the null terminator and the array decays to a pointer to the first element in this particular instance.

The data where that string is stored is the data section of your compiled executable and it is read-only (i.e. writing to it would probably trigger an access violation).

Answer 3

In C and C++, when you make a string literal, there is implicitly created a variable of type char[] with static storage duration to hold it. The string will be null-terminated as is consistent with C style.

The line

char* line2 = "hello";

is roughly equivalent to

static char __string_literal_line2[] = "hello";
// At top of program or something

...
char * line2 = __string_literal_line2;

So the char[] implicitly decays to a char* when you do it this way.

A wrinkle in this is that the array really is "const" in some sense and it is undefined behavior to try to modify it, but the C standard explicitly permits you to assign it to a char * anyways, so that legacy code that is not const-correct will still compile, and to be compatible C++ also permits this.

It's sometimes really convenient if you are doing compile-time programming to take advantage of the "true form" of the string literal. For instance in this code sample:

Passing constexpr objects around

class str_const {
    const char * const p_;
    const std::size_t sz_;
public:
    template <std::size_t N>
    constexpr str_const( const char( & a )[ N ] )
    : p_( a ), sz_( N - 1 ) {}

    ...
};

The str_const object can now be constructed as a constexpr at compile time from a string literal, and it will know the size of the string literal, even though normally you need to iterate or use C library functions to determine that. That's because it receives the string literal as a char[] rather than as a char *, and it can bind to the length of the array as part of the template deduction. So these expressions are legal, and the str_const object knows the lengths of the strings at compile-time:

str_const("foo");
str_const("foobar");
str_const("foobarbaz");

Answer 4

char test[] = "Hello" // adds H e l l o \0 in the stack 

When you do someting like f("Hello"), it reserves memory to store H e l l O \0 When you do

char *test = "Hello";

It stores Hello too somewhere and initialize test to the memory case where the 'H' is stored.

Basically pointers are 4 bytes integers. You should try to a program asking a password and verifying like this :

if(password == "mypassword")

and your job is to find "mypassword" in the generated binary.