What is the difference between char array[] and char *array?

Question

What is the difference between doing these two options, and why is the second type deprecated in C++?

char hello[] = {'h', 'e', 'l', 'l', 'o', '\0'};

char *hello = "hello";

But in correct c++ the second should be:

const char *hello = "hello";

For the most part I guess you are never going to change "hello", but why can't you change this memory if you wanted to?

That is only if you want to use std classes, a string in C++ doesn't have to use a string class — OnlyJoe, Jan 20 '14 at 02:12
You're asking about methods of representing string literals in C++. While you still **can** do both `char[]` and `char*`, the propper way in C++ is using the `string` library. http://stackoverflow.com/questions/10022117/why-should-one-use-stdstring-over-c-style-strings-in-c In short: There's no real reason to stay with `char` tables other than working with old code, where you have no real choice. — Paweł Stawarz, Jan 20 '14 at 02:16
I think this is one of FAQ for C programmers; please refer to http://c-faq.com/aryptr/ — nodakai, Jan 20 '14 at 02:24
I don't disagree at all that you would normally use std::string when working with strings. I was just wondering more about whether there is an actual difference between the way a compiler deals with sorting out the above example, and why the second example has been deprecated. — OnlyJoe, Jan 20 '14 at 02:35

score 4 · Accepted Answer · edited Jun 20 '20 at 09:12

char hello[] = {'h', 'e', 'l', 'l', 'o', '\0'};

This creates an array of 6 bytes in writable memory (on the stack if this is inside a function, in a data segment if directly at global scope or inside a namespace), to be initialised with the ASCII codes for each of those characters in turn.

char *hello = "hello";

"hello" is a string literal, which typically means:

the OS loader code that loads your program into memory and starts it running will have copied the text "hello\0" from your executable image into some memory that will then have been set to be read only, and
a separate variable named "hello" - which is of whatever size pointers are in your program (e.g. 4 bytes for 32-bit applications, 8 for 64-bit) - will exist on the stack (if the line above appears inside a function) or in writable memory segment (if the line is at global or namespace scope), and the address of the former textual data will be copied into the hello pointer.
you can change hello to point somewhere else (e.g. to another language's equivalent text), but normally shouldn't try to change the string literal to which the above code points hello... see below.

But in correct c++ the second should be:

const char *hello = "hello";

Yes - that's much better. For backwards compatibility, C++ has historically allowed non-const pointers to string literals, but actually modifying them wasn't guaranteed to be possible. Some compilers always, or can optionally (when asked by command line arguments), put string literals in writable memory. But, even if they are writable, changing them leads to lots of potential for errors. Say you have code like this and compiler flags to allow it to compile:

char* end = "end";
if (mixed_case_mode) end[0] = 'E';
if (s == "end") ...;

Then some completely unrelated code that does this...

std::cout << "this is the " << (x ? "start": "end");

...might start printing "End" if all mentions of "end" shared the same memory - a common and desirable optimisation. Turning this off can be quite wasteful, and while it allows this hackery to work with less unintended side effects to unrelated uses of the text, it's still very hard to reason about the code and debug when if (s == "end") might not actually be comparing s to "end".

score 1 · Answer 2 · answered Jan 20 '14 at 02:16

When you use [] you create an array which is a collection of items, chars in this case.

As you probably are aware, using * creates a pointer which might appear to be the same thing but is simply a single value (a memory address).

In essence the array creates a variable as large as the data where as the pointer just creates a 8 byte variable which contains the memory location of the string constant.

score 0 · Answer 3 · answered Jan 20 '14 at 03:12

If you want a string you can change, just use

char hello[] = "Hello";

This is legal and means exactly the same as your first statement. You can also reserve extra space, since you're writing you might want to store a bigger string later:

char hello[100] = "Hello";

score 0 · Answer 4 · answered Jan 20 '14 at 04:11

What is the difference between doing these two options

The first declares an array containing those characters. The second declares a pointer to a string literal: a static constant array containing the same characters. Or it would, if you were allowed to do that.

why is the second type deprecated in C++?

It isn't: it's forbidden, since the string literal is constant. Before C++11, it was allowed, but deprecated, to avoid breaking ancient code that didn't use const. In either case, attempting to modify the literal gives undefined behaviour.

why can't you change this memory if you wanted to?

Because string literals are constant. If you want some memory that you can change, you'll have to create your own array.

What is the difference between char array[] and char *array?

4 Answers4

Linked