Является ли инициализация char [] строковым литералом плохой практикой?

Я читал тему под названием «strlen vs sizeof» на CodeGuru , и в одном из ответов говорится, что «в любом случае [так] плохая практика - инициализировать [sic] charмассив со строковым литералом».

Это правда или это только его (хотя и "элитный член") мнение?

Вот оригинальный вопрос:

#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, но на длину после.

Что-то не так с моим синтаксисом или как?

Вот ответ :

В любом случае, плохо инициализировать массив символов строковым литералом. Поэтому всегда делайте одно из следующего:

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

В любом случае, плохо инициализировать массив символов строковым литералом.

Автор этого комментария никогда не оправдывает его, и я нахожу это утверждение загадочным.

В 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(для строк с нулем в конце), либо 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) происходит сбой при попытке записи на страницу, помеченную как доступную только для чтения. На других платформах может отображаться «сентябрь» и т. Д.

Тем не менее, инициализация литералом делает конкретную сумму резервирования, так что это не будет работать:

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 настаивает на том, что если какая-либо часть массива инициализируется, все это так. Так что в этом случае лучше сделать это самостоятельно. Я думаю, что это, возможно, было то, к чему добиралась treuss.

Точно

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 символов. Я не могу вспомнить, завершен ли он таким образом или нет - нить, на которую вы ссылались, заявила, что это так.

Копирование «сентябрь» поверх этой строки является очевидным переполнением памяти.

Другая проблема возникает, если вы переходите stringк другой функции, чтобы другая функция могла писать в массив. Вы должны указать другой функции, как долго будет работать массив, чтобы он не создавал переполнение. Вы можете передать stringрезультат, strlen()но поток объясняет, как это может взорваться, если stringне завершено нулем.

Вам лучше выделить строку с фиксированным размером (предпочтительно определяемым как константа), а затем передать массив и фиксированный размер другой функции. Комментарии @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 *), легко забыть, что вы не должны изменять этот массив.