为什么初始化char * []时需要const而string []不需要？

Question

char* c_arguments[] = { "hi","bye" }; //(1)
std::string cpp_arguments[]= { "hi","bye" };

(1) gives error in Visual Studio under C++17 standard

E0144: A value of type “const char*” cannot be used to initialize an entity of type “char *”

If I add const in the beginning the code compiles fine.

But why does the first line require const but the second line does not?

How to create char*[] without const from an array of string literals?

The code can use features of latest C++ standards and doesn't have to consider legacy systems.

Answer 1

The second line is calling copy constructors. Even though the literals are read-only the copies are not.

To create a pointer array to writable strings, you'll have to loop through and create a copy of each literal, just like the std::string constructor would do.

Answer 2

Strings are objects, under the hood, the compiler is creating two const char* buffers, and then copying those values into the string objects to give you mutable arrays. You could do the same to create your char* pointers if you wanted.

I wouldn't suggest using literal char* pointers without const in C++. There are a lot of ways to mess them up. If you want to modify a character buffer you should wrap them in a string and use the appropriate library functions.

Answer 3

The first type c_ is an array of pointers to char . The second type cpp_ is an array of std::string s.

When you pass a "string" to a pointer, it generates the pointer to the first element. But the type of the data in "hello" is const ; so a char* does not want to point at it. Instead you need a char const* , or a pointer to const char s.

For a std::string , when you pass "hello" to it, it copies the characters into a buffer owned by the std::string . The copy can be mutable, so there is no need for const .

There are compiler flags that discard the need for const when assigning a "hello" string literal to a char* ; they, however, exist for compatibility with code written before const was a thing. Avoid using them. If you modify, accidentally, the string constant after using those flags, you have undefined behaviour going on (most likely with string pooling you'll cause insanity)

Answer 4

In c++ there are essentially primitive data types and user defined data types. Primitive data types like int, char, pointers are built into the language. User defined types are built on the top of the primitive types.

Some of C++ user defined types are classes which can do some user defined actions under the hood. std::string is such a type. Objects of type string are initialized using a constructor.

All quoted string in c++ are const set of characters, meaning that the program has no right to modify them.

const char *str = "abc"; just declares a pointer to the constant string 'abc'. Therefore it must be 'const'.

std::string stdstr = "abc"; declares an object of class string from the namespace std . The initialization of the object calls a constructor of the string . The latter copies the string into internal storage. Copy cannot modify the "abc" character set. So, there is no conflict.

In the first case you cannot modify the pointer, in other words str[1] = 'd'; is illegal. it tires to modify the constant (read-only) string directly. In the second case you can modify the copy of "abc". stdstr[1] = 'd'; is legal.