用字符串字面量来初始化char []是不好的做法吗？

我在CodeGuru上读了一个标题为“ strlen vs sizeof”的线程，其中一个答复指出“ char用字符串文字初始化数组仍然是[sic]不好的做法”。

这是真的吗？还是他的观点（尽管是“精英成员”）？

这是原始问题：

#include <stdio.h>
#include<string.h>
main()
{
    char string[] = "october";
    strcpy(string, "september");

    printf("the size of %s is %d and the length is %d\n\n", string, sizeof(string), strlen(string));
    return 0;
}

对。大小应为长度加1是？

这是输出

the size of september is 8 and the length is 9

大小一定是10。就像在计算strcpy改变字符串长度之前计算它的sizeof字符串一样。

我的语法有问题吗？

这是答复：

无论如何，用字符串文字初始化char数组都是不好的做法。因此，请始终执行以下任一操作：

const char string1[] = "october";
char string2[20]; strcpy(string2, "september");

无论如何，用字符串文字初始化char数组都是不好的做法。

该评论的作者从未真正对其进行过论证，我觉得这一说法令人困惑。

在C（你已经标记以此为C），那是相当多的唯一途径初始化数组char与字符串值（初始化为分配不同）。你可以写

char string[] = "october";

要么

char string[8] = "october";

要么

char string[MAX_MONTH_LENGTH] = "october";

在第一种情况下，数组的大小取自初始化程序的大小。字符串文字存储为char以0结尾的字节数组，因此数组的大小为8（“ o”，“ c”，“ t”，“ o”，“ b”，“ e”，“ r”， 0）。在后两种情况下，将数组的大小指定为声明的一部分（8和MAX_MONTH_LENGTH，无论发生什么情况）。

你不能做的就是写类似

char string[];
string = "october";

要么

char string[8];
string = "october";

等。在第一种情况下，声明string是不完全的，因为没有指定数组大小，而且也没有初始化从采取的大小。在这两种情况下，这=都不起作用，因为a）数组表达式（例如string可能不是赋值的目标）和b）=运算符未定义为将一个数组的内容复制到另一个数组。

同样，您不能写

char string[] = foo;

foo的另一个数组在哪里char？这种初始化形式仅适用于字符串文字。

编辑

我应该对此进行修改，说您也可以使用数组样式的初始化程序来初始化数组以容纳字符串

char string[] = {'o', 'c', 't', 'o', 'b', 'e', 'r', 0};

要么

char string[] = {111, 99, 116, 111, 98, 101, 114, 0}; // assumes ASCII

但是使用字符串字面量在眼中更容易。

编辑²

为了在声明之外分配数组的内容，您将需要使用strcpy/strncpy（对于0终止的字符串）或memcpy（对于任何其他类型的数组）：

if (sizeof string > strlen("october"))
  strcpy(string, "october");

要么

strncpy(string, "october", sizeof string); // only copies as many characters as will
                                           // fit in the target buffer; 0 terminator
                                           // may not be copied, but the buffer is
                                           // uselessly completely zeroed if the
                                           // string is shorter!

我记得的唯一问题是将字符串文字分配给char *：

char var1[] = "september";
var1[0] = 'S'; // Ok - 10 element char array allocated on stack
char const *var2 = "september";
var2[0] = 'S'; // Compile time error - pointer to constant string
char *var3 = "september";
var3[0] = 'S'; // Modifying some memory - which may result in modifying... something or crash

例如，使用以下程序：

#include <stdio.h>

int main() {
  char *var1 = "september";
  char *var2 = "september";
  var1[0] = 'S';
  printf("%s\n", var2);
}

当我尝试将其写入标记为只读的页面时，它在我的平台（Linux）上崩溃。在其他平台上，它可能会打印“ September”等。

就是说-通过文字初始化会产生特定的预留量，因此将无法正常工作：

char buf[] = "May";
strncpy(buf, "September", sizeof(buf)); // Result "Sep"

但这会

char buf[32] = "May";
strncpy(buf, "September", sizeof(buf));

最后一句话-我完全不会使用strcpy：

char buf[8];
strcpy(buf, "very long string very long string"); // Oops. We overwrite some random memory

尽管某些编译器可以将其更改为安全调用strncpy，但要安全得多：

char buf[1024];
strncpy(buf, something_else, sizeof(buf)); // Copies at most sizeof(buf) chars so there is no possibility of buffer overrun. Please note that sizeof(buf) works for arrays but NOT pointers.
buf[sizeof(buf) - 1] = '\0';

这两个线程都没有提出的一件事是：

char whopping_great[8192] = "foo";

与

char whopping_great[8192];
memcpy(whopping_great, "foo", sizeof("foo"));

前者将执行以下操作：

memcpy(whopping_great, "foo", sizeof("foo"));
memset(&whopping_great[sizeof("foo")], 0, sizeof(whopping_great)-sizeof("foo"));

后者仅执行memcpy。C标准坚持认为，如果数组的任何部分都已初始化，则全部被初始化。因此，在这种情况下，最好自己动手做。我认为这可能是大乱斗的结果。

当然

char whopping_big[8192];
whopping_big[0] = 0;

胜过任何一个：

char whopping_big[8192] = {0};

要么

char whopping_big[8192] = "";

ps对于奖励积分，您可以执行以下操作：

memcpy(whopping_great, "foo", (1/(sizeof("foo") <= sizeof(whopping_great)))*sizeof("foo"));

如果您要使数组溢出，则抛出编译时除以零的错误。

主要是因为您没有char[]可以在程序中轻松使用的变量/构造的大小。

来自链接的代码示例：

 char string[] = "october";
 strcpy(string, "september");

string在堆栈上分配的长度为7或8个字符。我不记得它是否以这种方式为null终止-您链接到的线程声明它是。

在该字符串上复制“ 9月”显然是内存溢出。

如果传递string给另一个函数，以便另一个函数可以写入数组，则会带来另一个挑战。您需要告诉其他函数数组多长时间，这样就不会造成溢出。您可以传递string的结果，strlen()但是该线程说明了如果string不以null终止的话，如何将其炸毁。

最好分配一个固定大小（最好定义为常量）的字符串，然后将数组和固定大小的字符串传递给另一个函数。@John Bode的评论是正确的，并且有减轻这些风险的方法。他们还需要您付出更多的努力才能使用它们。

根据我的经验，对于char[]要放置在其中的其他值，初始化到的值通常太小。使用定义的常数有助于避免该问题。

sizeof string将为您提供缓冲区的大小（8个字节）；使用该表达式的结果，而不用strlen担心内存。
同样，你可以做一个检查之前的号召strcpy，看看你的目标缓冲区足够大源字符串：if (sizeof target > strlen(src)) { strcpy (target, src); }。
是的，如果必须将数组传递给函数，则还需要传递其物理大小：foo (array, sizeof array / sizeof *array);。– 约翰·波德

我认为“不好的实践”想法来自以下形式：

char string[] = "october is a nice month";

从源计算机代码到堆栈隐式地进行了strcpy。

仅处理指向该字符串的链接更为有效。喜欢与：

char *string = "october is a nice month";

或直接：

strcpy(output, "october is a nice month");

（但是，当然，在大多数代码中，这可能并不重要）

从来没有很长时间，但是您应该避免将char []初始化为string，因为“ string”是const char *，并且您将其分配给char *。因此，如果将此char []传递给更改数据的方法，则可能会有有趣的行为。

值得称赞的是，我在char *中混入了一些char []，但这并不好，因为它们有些不同。

将数据分配给char数组没有错，但是由于使用此数组的目的是将其用作'string'（char *），因此很容易忘记您不应该修改此数组。