Initialiser un caractère [] avec une chaîne est-il une mauvaise pratique?

Je lisais un fil de discussion intitulé "strlen vs sizeof" sur CodeGuru , et l' une des réponses indique qu '"il est de toute façon [sic] mauvaise pratique d'initialiser un chartableau avec un littéral de chaîne".

Est-ce vrai ou s'agit-il simplement de son opinion (bien que "membre d'élite")?

Voici la question initiale:

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

droite. la taille devrait être la longueur plus 1 oui?

c'est la sortie

the size of september is 8 and the length is 9

la taille devrait être 10 sûrement. c'est comme si on calculait la taille de la chaîne avant qu'elle ne soit modifiée par strcpy mais par la longueur suivante.

Y at-il quelque chose qui ne va pas avec ma syntaxe ou quoi?

Voici la réponse :

C'est de toute façon une mauvaise pratique d'initialiser un tableau de caractères avec un littéral de chaîne. Alors, faites toujours l’une des choses suivantes:

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

C'est de toute façon une mauvaise pratique d'initialiser un tableau de caractères avec un littéral de chaîne.

L'auteur de ce commentaire ne le justifie jamais vraiment et je trouve la déclaration déconcertante.

En C (et vous l'avez étiqueté C), c'est à peu près la seule façon d' initialiser un tableau charavec une valeur de chaîne (l'initialisation est différente de l'attribution). Vous pouvez écrire soit

char string[] = "october";

ou

char string[8] = "october";

ou

char string[MAX_MONTH_LENGTH] = "october";

Dans le premier cas, la taille du tableau est prise à partir de la taille de l'initialiseur. Les littéraux de chaîne sont stockés en tant que tableaux de char0 octet de fin; la taille du tableau est donc 8 ('o', 'c', 't', 'o', 'b', 'e', ​​'r', 0) Dans les deux autres cas, la taille du tableau est spécifiée dans la déclaration (8 et MAX_MONTH_LENGTHquoi que ce soit).

Ce que vous ne pouvez pas faire, c'est écrire quelque chose comme

char string[];
string = "october";

ou

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

etc. Dans le premier cas, la déclaration de stringest incomplète car aucune taille de tableau n'a été spécifiée et aucun initialiseur à prendre la taille. Dans les deux cas, =cela ne fonctionnera pas car a) une expression de tableau telle que stringpouvant ne pas être la cible d'une affectation et b) l' =opérateur n'est pas défini pour copier le contenu d'un tableau dans un autre.

De même, vous ne pouvez pas écrire

char string[] = foo;

où fooest un autre tableau de char. Cette forme d'initialisation ne fonctionnera qu'avec les littéraux de chaîne.

MODIFIER

Je devrais modifier cela pour dire que vous pouvez également initialiser des tableaux pour contenir une chaîne avec un initialiseur de type tableau, comme

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

ou

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

mais il est plus facile pour les yeux d'utiliser des littéraux de chaîne.

EDIT ²

Pour affecter le contenu d'un tableau en dehors d'une déclaration, vous devez utiliser soit strcpy/strncpy(pour les chaînes terminées par 0), soit memcpy(pour tout autre type de tableau):

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

ou

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!

Le seul problème que je me rappelle est l’assignation du littéral chaîne à 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

Par exemple, prenez ce programme:

#include <stdio.h>

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

Ceci sur ma plate-forme (Linux) se bloque lorsqu’il essaie d’écrire sur une page marquée en lecture seule. Sur d’autres plates-formes, il peut imprimer «septembre», etc.

Cela dit - l'initialisation par le littéral fait le montant spécifique de la réservation pour que cela ne fonctionne pas:

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

Mais ce sera

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

Dernière remarque - je n’utiliserais pas strcpydu tout:

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

Bien que certains compilateurs puissent le transformer en appel sécurisé, cela strncpyest beaucoup plus sûr:

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

Une chose que ni l'un ni l'autre des fils ne soulève est la suivante:

char whopping_great[8192] = "foo";

contre.

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

Le premier fera quelque chose comme:

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

Ce dernier ne fait que la mémoire. Le standard C insiste sur le fait que si une partie d’un tableau est initialisée, c’est le cas. Donc, dans ce cas, il vaut mieux le faire soi-même. Je pense que c’est peut-être à cela que voulait arriver Treuss.

Pour sûr

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

est mieux que soit:

char whopping_big[8192] = {0};

ou

char whopping_big[8192] = "";

ps Pour les points bonus, vous pouvez faire:

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

générer une erreur de division du temps de compilation par zéro si vous êtes sur le point de déborder du tableau.

Principalement parce que vous n'avez pas la taille de la char[]variable / construction que vous pouvez facilement utiliser dans le programme.

L'échantillon de code du lien:

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

stringest alloué sur la pile sur 7 ou 8 caractères. Je ne me souviens pas si c'est terminé de cette façon ou non - le fil que vous avez lié a déclaré qu'il en était ainsi.

Copier "septembre" sur cette chaîne est un dépassement de mémoire évident.

Un autre défi survient si vous passez stringà une autre fonction afin que cette dernière puisse écrire dans le tableau. Vous devez dire à l'autre fonction combien de temps le tableau est si elle ne crée pas un dépassement. Vous pourriez passer stringavec le résultat de, strlen()mais le fil de discussion explique comment cela peut exploser s'il stringn'est pas terminé par null.

Il vaut mieux allouer une chaîne de taille fixe (définie de préférence comme une constante), puis passer le tableau et la taille fixe à l'autre fonction. Les commentaires de @John Bode sont corrects et il existe des moyens d'atténuer ces risques. Ils nécessitent également plus d’efforts de votre part pour les utiliser.

D'après mon expérience, la valeur que j'ai initialisée char[]à est généralement trop petite pour les autres valeurs que je dois y placer. L'utilisation d'une constante définie permet d'éviter ce problème.

sizeof stringvous donnera la taille du tampon (8 octets); utilisez le résultat de cette expression plutôt que strlenlorsque vous vous préoccupez de mémoire.
De même, vous pouvez faire un chèque avant l'appel strcpypour voir si votre tampon cible est assez grand pour la chaîne source: if (sizeof target > strlen(src)) { strcpy (target, src); }.
Oui, si vous devez passer le tableau à une fonction, vous aurez besoin de passer sa taille physique ainsi: foo (array, sizeof array / sizeof *array);. - John Bode

Je pense que l'idée de "mauvaise pratique" vient du fait que cette forme:

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

fait implicitement une strcpy du code de la machine source à la pile.

Il est plus efficace de gérer uniquement un lien vers cette chaîne. J'aime avec:

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

ou directement:

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

(mais bien sûr dans la plupart des codes cela n'a probablement pas d'importance)

Il ne faut jamais trop de temps, mais évitez d’initialiser char [] en chaîne, car "chaîne" est const char *, et vous l’assignez à char *. Donc, si vous passez ce caractère [] à la méthode qui modifie les données, vous pouvez avoir un comportement intéressant.

Comme recommandé, j'ai mélangé un peu char [] avec char *, ce n'est pas bien, car ils diffèrent un peu.

Il n'y a rien de mal à assigner des données à un tableau de caractères, mais comme l'intention d'utiliser ce tableau est de l'utiliser comme 'chaîne' (char *), il est facile d'oublier que vous ne devez pas modifier ce tableau.