Whats the practical diffrens between these declarations in c?

char *a_str = "hello";

char a_str[] = "hello";

You should get an error from:
because that is assigning a pointer value of type (const char *) to a variable defined to have type (char *). The compiler MAY choose to create a private instance of the string literal "hello" just for this. If you had
you could (probably should) get the exact same pointer value stored in a_str and b_str. However with
if it doesn't flag that as a pointer type assignment/initialization error, it should give unique pointer values to each.

So, what if you mean to use const in your definition. Then, what is the practical difference? One makes a pointer object and arranges for it to point to a string literal somewhere. The other makes string space and initializes it. The practicality depends on your usage.

If you need a pointer that at different times may point to different strings, but needs to initially point some first string, the first example (with const) would do well. You can modify the pointer to point to other strings, later.

If you need string space that can be modified in place, but not increased in size, the second example would do well. You would get just enough space to hold the initial value. You may get more, but you cannot depend on that.

Thanks for the clearification.

I thought that specific abuse was grandfathered in from before it was considered incorrect, so normal compiler settings would not give you an error.

That "hello" ought to be const. It may cause a seg fault or worse if you actually write to it. But the compiler lets you assign its address to a pointer to non const.

"MAY" is hard to argue against. But I don't think the compiler does that.

I don't think so.

That is the answer to the question the OP asked.

Additionally, the first makes a non const pointer to a potentially shared, potentially read only literal. So writing through that pointer would be a run time error. The second makes a non shared writable copy of the text, so writing through that pointer (within range) is fine.

Unfortunately many C functions are declared and used in a way that prevents the compiler from knowing whether a char* will be written through. So the programmer must use char* for many pointers that logically ought to be char const* and pass those pointers to functions that from the compiler's viewpoint might be writing through the pointers. It is the programmer's responsibility then to track the way those functions are used to know that these pointers won't actually get written through.

1 members found this post helpful.

That's why I used MAY and emphasized it. A compiler trying to be safe about a grandfathered scenario might WANT to do that. I don't know that any do this.