strtok-字符数组与字符指针[重复]-strtok-chararrayversuscharpointer[duplicate]

26  

char string[] = "hello world";

This line initializes string to be a big-enough array of characters (in this case char[12]). It copies those characters into your local array as though you had written out

这一行将字符串初始化为足够大的字符数组(在本例中为char[12])。它将这些字符复制到本地数组中，就像您编写的那样

char string[] = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0' };

The other line:

其他线:

char* string = "hello world";

does not initialize a local array, it just initializes a local pointer. The compiler is allowed to set it to a pointer to an array which you're not allowed to change, as though the code were

不初始化一个本地数组，它只是初始化一个本地指针。编译器可以将它设置为指向数组的指针，而不允许对数组进行修改，就像代码一样

const char literal_string[] = "hello world";
char* string = (char*) literal_string;

The reason C allows this without a cast is mainly to let ancient code continue compiling. You should pretend that the type of a string literal in your source code is const char[], which can convert to const char*, but never convert it to a char*.

C之所以允许这样的原因，主要是为了让古老的代码继续编译。您应该假定您的源代码中的字符串文字的类型是const char[]，它可以转换为const char*，但永远不要将它转换为char*。

11  

In the second example:

在第二个例子中:

char *string = "hello world";
char *result = strtok(string, " ");

the pointer string is pointing to a string literal, which cannot be modified (as strtok() would like to do).

指针字符串指向字符串文字，不能修改它(就像strtok()想做的那样)。

You could do something along the lines of:

你可以做一些类似的事情:

char *string = strdup("hello world");
char *result = strtok(string, " ");

so that string is pointing to a modifiable copy of the literal.

这个字符串指向文字的可修改拷贝。

4  

strtok modifies the string you pass to it (or tries to anyway). In your first code, you're passing the address of an array that's been initialized to a particular value -- but since it's a normal array of char, modifying it is allowed.

strtok修改您传递给它的字符串(或者尝试使用它)。在您的第一个代码中，您传递的是一个被初始化为特定值的数组的地址——但是由于它是一个正常的char数组，所以可以修改它。

In the second code, you're passing the address of a string literal. Attempting to modify a string literal gives undefined behavior.

在第二段代码中，传递字符串文字的地址。尝试修改字符串文字会产生未定义的行为。

3  

In the second case (char *), the string is in read-only memory. The correct type of string constants is const char *, and if you used that type to declare the variable you would get warned by the compiler when you tried to modify it. For historical reasons, you're allowed to use string constants to initialize variables of type char * even though they can't be modified. (Some compilers let you turn this historic license off, e.g. with gcc's -Wwrite-strings.)

在第二种情况(char *)中，字符串位于只读内存中。字符串常量的正确类型是const char *，如果您使用该类型声明变量，那么当您试图修改它时，编译器将警告您。出于历史原因，您可以使用字符串常量来初始化类型char *的变量，即使它们不能被修改。(一些编译器允许您关闭这个历史许可证，例如使用gcc的-Wwrite-strings。)

0  

The first case creates a (non const) char array that is big enough to hold the string and initializes it with the contents of the string. The second case creates a char pointer and initializes it to point at the string literal, which is probably stored in read only memory.

第一个案例创建了一个(非const) char数组，它足够大，可以容纳字符串并使用字符串的内容初始化它。第二种情况创建一个char指针并初始化它到指向字符串文字，它可能存储在只读内存中。

Since strtok wants to modify the memory pointed at by the argument you pass it, the latter case causes undefined behavior (you're passing in a pointer that points at a (const) string literal), so its unsuprising that it crashes

由于strtok希望修改您传递它的参数所指向的内存，所以后一种情况会导致未定义的行为(您正在传递指向(const)字符串文字的指针)，因此它不会意外地导致它崩溃

0  

Because the second one declares a pointer (that can change) to a constant string...

因为第二个声明一个指针(可以改变)到一个常量字符串……

So depending on your compiler / platform / OS / memory map... the "hello world" string will be stored as a constant (in an embedded system, it may be stored in ROM) and trying to modify it will cause that error.

所以取决于你的编译器/平台/操作系统/内存映射…“hello world”字符串将作为常量存储(在嵌入式系统中，它可能存储在ROM中)，并试图修改它将导致错误。