Czy inicjowanie char [] za pomocą dosłownego ciągu znaków jest złą praktyką?

Czytałem wątek zatytułowany „strlen vs sizeof” na CodeGuru , a jedna z odpowiedzi mówi, że „w każdym razie [sic] złą praktyką jest inicjowanie [sic] chartablicy z dosłownym ciągiem znaków”.

Czy to prawda, czy to tylko jego (choć „elitarny członek”) opinia?

Oto oryginalne pytanie:

#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;
}

dobrze. rozmiar powinien być równy długości plus 1 tak?

to jest wynik

the size of september is 8 and the length is 9

rozmiar powinien z pewnością wynosić 10. to jak obliczanie rozmiaru ciągu przed zmianą przez strcpy, ale długość po nim.

Czy coś jest nie tak z moją składnią?

Oto odpowiedź :

W każdym razie złą praktyką jest inicjałowanie tablicy znaków literałem łańcuchowym. Dlatego zawsze wykonaj jedną z następujących czynności:

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

W każdym razie złą praktyką jest inicjałowanie tablicy znaków literałem łańcuchowym.

Autor tego komentarza tak naprawdę nigdy go nie usprawiedliwia, a stwierdzenie to mnie zastanawia.

W C (i oznaczyłeś to jako C), jest to prawie jedyny sposób na zainicjowanie tablicy charz wartością ciągu (inicjalizacja różni się od przypisania). Możesz napisać albo

char string[] = "october";

lub

char string[8] = "october";

lub

char string[MAX_MONTH_LENGTH] = "october";

W pierwszym przypadku rozmiar tablicy jest pobierany z rozmiaru inicjatora. Literały łańcuchowe są przechowywane jako tablice charz końcowym bajtem 0, więc rozmiar tablicy wynosi 8 („o”, „c”, „t”, „o”, „b”, „e”, „r”, 0). W dwóch pozostałych przypadkach rozmiar tablicy jest określony jako część deklaracji (8 i MAX_MONTH_LENGTH, cokolwiek by się nie zdarzyło).

Czego nie może zrobić, to napisać coś

char string[];
string = "october";

lub

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

itd. W pierwszym przypadku deklaracja stringjest niekompletna, ponieważ nie określono rozmiaru tablicy i nie ma inicjatora, z którego można by pobrać rozmiar. W obu przypadkach =nie zadziała, ponieważ a) wyrażenie tablicowe, które stringmoże nie być celem zadania ib) =operator nie jest zdefiniowany tak, aby kopiować zawartość jednej tablicy do drugiej.

Z tego samego powodu nie możesz pisać

char string[] = foo;

gdzie foojest kolejna tablica char. Ta forma inicjalizacji będzie działać tylko z literałami łańcuchowymi.

EDYTOWAĆ

Powinienem to zmienić, aby powiedzieć, że możesz także inicjować tablice, aby przechowywać ciąg znaków za pomocą inicjatora w stylu tablicowym

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

lub

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

ale łatwiej jest oczom używać literałów łańcuchowych.

EDYCJA ²

Aby przypisać zawartość tablicy poza deklaracją, musisz użyć albo strcpy/strncpy(dla łańcuchów zakończonych 0) lub memcpy(dla dowolnego innego typu tablicy):

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

lub

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!

Jedyny problem, jaki pamiętam, to przypisanie literału ciągów do 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

Na przykład weź ten program:

#include <stdio.h>

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

To na mojej platformie (Linux) ulega awarii podczas próby zapisu na stronie oznaczonej jako tylko do odczytu. Na innych platformach może drukować „wrzesień” itp.

To powiedziawszy - inicjalizacja przez literał powoduje określoną liczbę rezerwacji, więc to nie zadziała:

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

Ale to będzie

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

Ostatnia uwaga - w ogóle nie używałbym strcpy:

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

Chociaż niektóre kompilatory mogą zmienić to w bezpieczne wywołanie, strncpyjest o wiele bezpieczniejsze:

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';

Jedną rzeczą, której nie porusza żaden wątek, jest to:

char whopping_great[8192] = "foo";

vs.

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

Ten pierwszy zrobi coś takiego:

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

Ten ostatni robi tylko memcpy. Standard C nalega, aby inicjalizować dowolną część tablicy, wszystko jest w porządku. W takim przypadku lepiej to zrobić samemu. Wydaje mi się, że o to właśnie chodziło.

Na pewno

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

jest lepszy niż:

char whopping_big[8192] = {0};

lub

char whopping_big[8192] = "";

ps Aby uzyskać punkty bonusowe, możesz:

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

aby rzucić czas kompilacji podziel przez błąd zero, jeśli masz zamiar przepełnić tablicę.

Przede wszystkim dlatego, że nie będziesz mieć wielkości char[]zmiennej / konstrukcji, której można łatwo użyć w programie.

Przykładowy kod z linku:

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

stringjest przydzielany na stosie jako 7 lub 8 znaków. Nie mogę sobie przypomnieć, czy jest zakończone zerem w ten sposób, czy nie - wątek, do którego linkujesz, stwierdził, że tak.

Kopiowanie „września” nad tym ciągiem jest oczywistym przepełnieniem pamięci.

Kolejne wyzwanie pojawia się, jeśli przejdziesz stringdo innej funkcji, aby inna funkcja mogła zapisać się w tablicy. Trzeba powiedzieć, że inne funkcje, jak długo tablica jest tak , że nie tworzy przepełnienie. Możesz przekazać stringwraz z wynikiem, strlen()ale wątek wyjaśnia, jak to może wybuchnąć, jeśli stringnie jest zakończone zerem.

Lepiej jest przydzielić ciąg znaków o stałym rozmiarze (najlepiej zdefiniowanym jako stała), a następnie przekazać tablicę i stały rozmiar innej funkcji. Komentarze Johna Bode'a są poprawne i istnieją sposoby na ograniczenie tego ryzyka. Wymagają również więcej wysiłku z Twojej strony, aby z nich korzystać.

Z mojego doświadczenia char[]wynika , że wartość, którą zainicjowałem, jest zwykle zbyt mała dla innych wartości, które muszę tam umieścić. Korzystanie ze zdefiniowanej stałej pomaga uniknąć tego problemu.

sizeof stringpoda rozmiar bufora (8 bajtów); użyj wyniku tego wyrażenia zamiast strlengdy martwisz się pamięcią.
Podobnie można wykonać test przed wywołanie strcpyaby sprawdzić, czy bufor docelowy jest wystarczająco duży dla łańcucha źródłowego: if (sizeof target > strlen(src)) { strcpy (target, src); }.
Tak, jeśli masz przekazać tablicę do funkcji, musisz przekazać swoje fizyczne wymiary, a także: foo (array, sizeof array / sizeof *array);. - John Bode

Myślę, że pomysł „złej praktyki” wynika z faktu, że ta forma:

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

czyni domyślnie strcpy ze źródłowego kodu maszynowego na stos.

Bardziej wydajne jest obsługiwanie tylko linku do tego ciągu. Podobnie jak w przypadku:

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

lub bezpośrednio:

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

(ale oczywiście w większości kodów to chyba nie ma znaczenia)

Nigdy nie jest naprawdę długi czas, ale należy unikać inicjalizacji char [] do string, ponieważ „string” jest const char *, a ty przypisujesz go do char *. Więc jeśli przekażesz ten znak [] metodzie, która zmienia dane, możesz mieć ciekawe zachowanie.

Jak powiedział komenda, wymieszałem trochę char [] z char *, to nie jest dobre, ponieważ się trochę różnią.

Nie ma nic złego w przypisywaniu danych do tablicy char, ale ponieważ intencją użycia tej tablicy jest użycie jej jako „łańcucha” (char *), łatwo zapomnieć, że nie należy modyfikować tej tablicy.