Ist das Initialisieren eines Zeichens [] mit einem String-Literal eine schlechte Übung?

Ich habe einen Thread mit dem Titel "strlen vs sizeof" auf CodeGuru gelesen , und eine der Antworten besagt, dass "es sowieso eine schlechte Praxis ist, ein charArray mit einem String-Literal zu initialisieren ".

Stimmt das, oder ist das nur seine (wenn auch "Elite-Mitglied") Meinung?

Hier ist die ursprüngliche Frage:

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

richtig. die größe sollte die länge plus 1 sein ja?

das ist die Ausgabe

the size of september is 8 and the length is 9

größe sollte sicher 10 sein. Es ist wie das Berechnen der Zeichenfolgengröße, bevor es von strcpy geändert wird, aber die Länge danach.

Stimmt etwas mit meiner Syntax nicht oder was?

Hier ist die Antwort :

Es ist sowieso eine schlechte Praxis, ein Zeichen-Array mit einem String-Literal zu initialisieren. Führen Sie daher immer einen der folgenden Schritte aus:

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

Es ist sowieso eine schlechte Praxis, ein Zeichen-Array mit einem String-Literal zu initialisieren.

Der Autor dieses Kommentars rechtfertigt es nie wirklich, und ich finde die Aussage rätselhaft.

In C (und Sie dies als C markiert haben), das ist so ziemlich der einzige Weg zu initialisieren ein Array von charmit einem String - Wert (Initialisierung unterscheidet sich von Zuordnung). Sie können entweder schreiben

char string[] = "october";

oder

char string[8] = "october";

oder

char string[MAX_MONTH_LENGTH] = "october";

Im ersten Fall wird die Größe des Arrays von der Größe des Initialisierers abgeleitet. String-Literale werden als Arrays charmit einem abschließenden 0-Byte gespeichert , sodass die Größe des Arrays 8 ist ('o', 'c', 't', 'o', 'b', 'e', ​​'r', 0). In den zweiten beiden Fällen wird die Größe des Arrays als Teil der Deklaration angegeben (8 und MAX_MONTH_LENGTHwas auch immer das sein mag).

Was Sie nicht tun können, ist etwas zu schreiben

char string[];
string = "october";

oder

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

usw. Im ersten Fall, der die Erklärung stringist unvollständig , da keine Array - Größe angegeben wurde und es gibt keine Initialisierer von der Größe zu nehmen. In beiden Fällen =funktioniert das nicht, weil a) ein Array-Ausdruck, wie er stringmöglicherweise nicht das Ziel einer Zuweisung ist, und b) der =Operator ohnehin nicht definiert ist, den Inhalt eines Arrays in ein anderes zu kopieren.

Aus dem gleichen Grund können Sie nicht schreiben

char string[] = foo;

wo fooist ein anderes Array von char. Diese Form der Initialisierung funktioniert nur mit String-Literalen.

BEARBEITEN

Ich sollte dies dahingehend ändern, dass Sie Arrays auch so initialisieren können, dass sie eine Zeichenfolge mit einem Initialisierer im Array-Stil enthalten, z

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

oder

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

Aber es ist für die Augen einfacher, String-Literale zu verwenden.

BEARBEITEN ²

Um den Inhalt eines Arrays außerhalb einer Deklaration zuzuweisen , müssen Sie entweder strcpy/strncpy(für Zeichenfolgen mit 0-Abschluss) oder memcpy(für jeden anderen Array-Typ) Folgendes verwenden:

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

oder

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!

Das einzige Problem, an das ich mich erinnere, ist das Zuweisen von Zeichenfolgenliteral zu 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

Nehmen Sie zum Beispiel dieses Programm:

#include <stdio.h>

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

Dies stürzt auf meiner Plattform (Linux) ab, wenn versucht wird, auf eine Seite zu schreiben, die als schreibgeschützt markiert ist. Auf anderen Plattformen wird möglicherweise "September" usw. gedruckt.

Das heißt, die Initialisierung durch Literal bewirkt, dass der bestimmte Reservierungsbetrag nicht funktioniert:

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

Aber das wird es

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

Als letzte Bemerkung - würde ich gar nicht verwenden strcpy:

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

Während einige Compiler es in einen sicheren Aufruf umwandeln können, ist es strncpyviel sicherer:

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

Eine Sache, die keiner der Themen aufwirft, ist die folgende:

char whopping_great[8192] = "foo";

gegen

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

Ersterer wird so etwas tun wie:

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

Letzteres macht nur die memcpy. Der C-Standard besteht darauf, dass, wenn ein Teil eines Arrays initialisiert wird, dies auch der Fall ist. In diesem Fall ist es also besser, es selbst zu tun. Ich denke, das war vielleicht das, worauf Treuss abzielte.

Sicher

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

ist besser als entweder:

char whopping_big[8192] = {0};

oder

char whopping_big[8192] = "";

ps Für Bonuspunkte können Sie Folgendes tun:

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

um eine durch Null geteilte Kompilierzeit zu erhalten, wenn das Array überlaufen soll.

In erster Linie, weil Sie nicht die Größe von char[]in einer Variablen / einem Konstrukt haben, die / das Sie einfach im Programm verwenden können.

Das Codebeispiel aus dem Link:

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

stringwird auf dem Stapel mit einer Länge von 7 oder 8 Zeichen zugewiesen. Ich kann mich nicht erinnern, ob es auf diese Weise nullterminiert wurde oder nicht - der Thread, mit dem Sie verlinkt haben, hat dies bestätigt.

Das Kopieren von "September" über diesen String ist ein offensichtlicher Speicherüberlauf.

Eine weitere Herausforderung ergibt sich, wenn Sie an stringeine andere Funktion übergeben, damit die andere Funktion in das Array schreiben kann. Sie müssen der anderen Funktion mitteilen, wie lang das Array ist, damit es nicht zu einem Überlauf kommt. Sie könnten stringdas Ergebnis von weitergeben, strlen()aber der Thread erklärt, wie dies explodieren kann, wenn stringes nicht nullterminiert ist.

Sie sollten einen String mit einer festen Größe (vorzugsweise als Konstante definiert) zuweisen und dann das Array und die feste Größe an die andere Funktion übergeben. @ John Bodes Kommentar (e) sind korrekt, und es gibt Möglichkeiten, diese Risiken zu mindern. Sie erfordern auch mehr Aufwand von Ihrer Seite, um sie zu verwenden.

Nach meiner Erfahrung ist der Wert, den ich für initialisiert habe char[], normalerweise zu klein für die anderen Werte, die ich dort einfügen muss. Die Verwendung einer definierten Konstante hilft, dieses Problem zu vermeiden.

sizeof stringgibt Ihnen die Größe des Puffers (8 Bytes); Verwenden Sie das Ergebnis dieses Ausdrucks, anstatt sich strlenGedanken über das Gedächtnis zu machen.
Ebenso können Sie einen Scheck, bevor der Anruf an , strcpyum zu sehen , ob Ihre Zielpuffer groß genug für die Quellzeichenfolge ist: if (sizeof target > strlen(src)) { strcpy (target, src); }.
Ja, wenn Sie das Array an eine Funktion haben, müssen Sie auch seine physische Größe weitergeben müssen: foo (array, sizeof array / sizeof *array);. - John Bode

Ich denke, die Idee der "schlechten Praxis" kommt von der Tatsache, dass diese Form:

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

macht implizit einen strcpy vom Quellmaschinencode zum Stack.

Es ist effizienter, nur eine Verknüpfung zu dieser Zeichenfolge zu verarbeiten. Wie mit :

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

oder direkt:

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

(aber in den meisten Codes spielt es wahrscheinlich keine Rolle)

Nie ist wirklich viel Zeit, aber Sie sollten die Initialisierung von char [] to string vermeiden, da "string" const char * ist und Sie es char * zuweisen. Wenn Sie also dieses Zeichen [] an die Methode übergeben, die Daten ändert, kann dies zu einem interessanten Verhalten führen.

Wie gesagt, ich habe ein bisschen char [] mit char * gemischt, das ist nicht gut, da sie sich ein bisschen unterscheiden.

Es ist nichts Falsches daran, einem char-Array Daten zuzuweisen, aber da dieses Array als 'String' (char *) verwendet werden soll, kann leicht vergessen werden, dass Sie dieses Array nicht ändern sollten.