L'inizializzazione di un carattere [] con una stringa è una cattiva pratica letterale?

Stavo leggendo un thread intitolato "strlen vs sizeof" su CodeGuru e una delle risposte afferma che "è comunque una cattiva pratica inizializzare [sic] un chararray con una stringa letterale".

È vero, o è solo la sua opinione (sebbene un "membro d'élite")?

Ecco la domanda originale:

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

destra. la dimensione dovrebbe essere la lunghezza più 1 sì?

questo è l'output

the size of september is 8 and the length is 9

la dimensione dovrebbe essere sicuramente 10. è come calcolare la dimensione della stringa prima che venga cambiata da strcpy ma la lunghezza dopo.

C'è qualcosa di sbagliato nella mia sintassi o cosa?

Ecco la risposta :

È comunque una cattiva pratica inizializzare un array di caratteri con una stringa letterale. Quindi esegui sempre una delle seguenti operazioni:

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

È comunque una cattiva pratica inizializzare un array di caratteri con una stringa letterale.

L'autore di quel commento non lo giustifica mai e trovo sconcertante l'affermazione.

In C (e l'hai etichettato come C), è praticamente l'unico modo per inizializzare un array charcon un valore stringa (l'inizializzazione è diversa dall'assegnazione). Puoi anche scrivere

char string[] = "october";

o

char string[8] = "october";

o

char string[MAX_MONTH_LENGTH] = "october";

Nel primo caso, la dimensione dell'array viene presa dalla dimensione dell'inizializzatore. I letterali di stringa sono memorizzati come matrici di charcon 0 byte di terminazione, quindi la dimensione della matrice è 8 ('o', 'c', 't', 'o', 'b', 'e', ​​'r', 0). Nei secondi due casi, la dimensione dell'array viene specificata come parte della dichiarazione (8 e MAX_MONTH_LENGTH, qualunque cosa accada).

Quello che non puoi fare è scrivere qualcosa del genere

char string[];
string = "october";

o

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

ecc. Nel primo caso, la dichiarazione di stringè incompleta perché non è stata specificata alcuna dimensione dell'array e non esiste un inizializzatore da cui prendere la dimensione. In entrambi i casi, =non funzionerà perché a) un'espressione di array come stringpotrebbe non essere la destinazione di un compito eb) l' =operatore non è definito per copiare comunque i contenuti di un array su un altro.

Per lo stesso motivo, non puoi scrivere

char string[] = foo;

dov'è fooun altro array di char. Questa forma di inizializzazione funzionerà solo con valori letterali stringa.

MODIFICARE

Dovrei modificare questo per dire che puoi anche inizializzare le matrici per contenere una stringa con un inizializzatore in stile array, come

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

o

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

ma è più facile per gli occhi usare letterali stringa.

MODIFICA ²

Per assegnare il contenuto di un array al di fuori di una dichiarazione, è necessario utilizzare strcpy/strncpy(per stringhe con terminazione 0) o memcpy(per qualsiasi altro tipo di array):

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

o

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!

L'unico problema che ricordo è l'assegnazione di stringhe letterali a 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

Ad esempio prendi questo programma:

#include <stdio.h>

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

Questo sulla mia piattaforma (Linux) si arresta in modo anomalo mentre tenta di scrivere nella pagina contrassegnata come di sola lettura. Su altre piattaforme potrebbe stampare "settembre" ecc.

Detto questo, l'inizializzazione letterale rende l'ammontare specifico della prenotazione in modo che non funzioni:

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

Ma questo lo farà

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

Come ultima osservazione, non userei strcpyaffatto:

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

Mentre alcuni compilatori possono trasformarlo in chiamata sicura strncpyè molto più sicuro:

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

Una cosa che nessuno dei due thread fa apparire è questa:

char whopping_great[8192] = "foo";

vs.

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

Il primo farà qualcosa del tipo:

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

Quest'ultimo fa solo il memcpy. Lo standard C insiste sul fatto che se una parte di un array viene inizializzata, lo è tutto. Quindi, in questo caso, è meglio farlo da soli. Penso che potrebbe essere stato quello a cui Treuss stava arrivando.

Di sicuro

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

è meglio di entrambi:

char whopping_big[8192] = {0};

o

char whopping_big[8192] = "";

ps Per i punti bonus, puoi fare:

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

per generare una divisione del tempo di compilazione per errore zero se si sta per traboccare l'array.

Principalmente perché non avrai la dimensione di char[]in una variabile / costrutto che puoi facilmente usare all'interno del programma.

L'esempio di codice dal link:

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

stringè assegnato in pila con una lunghezza di 7 o 8 caratteri. Non riesco a ricordare se è terminato con null in questo modo o meno - il thread a cui hai collegato ha dichiarato che lo è.

Copiare "settembre" su quella stringa è un evidente sovraccarico di memoria.

Un'altra sfida si presenta se si passa stringa un'altra funzione in modo che l'altra funzione possa scrivere nell'array. È necessario indicare all'altra funzione quanto è lungo l'array in modo che non crei un sovraccarico. Potresti passare stringcon il risultato di strlen()ma il thread spiega come questo può esplodere se stringnon è terminato con null.

È meglio allocare una stringa con una dimensione fissa (preferibilmente definita come costante) e quindi passare l'array e la dimensione fissa all'altra funzione. I commenti di @John Bode sono corretti e ci sono modi per mitigare questi rischi. Richiedono anche maggiori sforzi da parte vostra per usarli.

Nella mia esperienza, il valore con cui ho inizializzato il char[]to di solito è troppo piccolo per gli altri valori che devo inserire. L'uso di una costante definita aiuta a evitare questo problema.

sizeof stringti darà la dimensione del buffer (8 byte); usa il risultato di quell'espressione invece che strlenquando sei preoccupato per la memoria.
Allo stesso modo, è possibile effettuare un controllo prima della chiamata a strcpyper verificare se il buffer di destinazione è abbastanza grande per la stringa di origine: if (sizeof target > strlen(src)) { strcpy (target, src); }.
Sì, se si deve passare la matrice a una funzione, sarà necessario passare la sua dimensione fisica così: foo (array, sizeof array / sizeof *array);. - John Bode

Penso che l'idea di "cattiva pratica" derivi dal fatto che questa forma:

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

rende implicitamente uno strcpy dal codice macchina sorgente allo stack.

È più efficiente gestire solo un collegamento a quella stringa. Come con:

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

o direttamente:

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

(ma ovviamente nella maggior parte del codice probabilmente non importa)

Non è mai molto tempo, ma dovresti evitare l'inizializzazione char [] su string, perché "string" è const char * e lo stai assegnando a char *. Quindi, se passi questo carattere [] al metodo che modifica i dati, puoi avere un comportamento interessante.

Come ha detto lode, ho mescolato un po 'char [] con char *, non va bene perché differiscono un po'.

Non c'è nulla di sbagliato nell'assegnare i dati all'array char, ma poiché l'intenzione di utilizzare questo array è di usarlo come 'string' (char *), è facile dimenticare che non si dovrebbe modificare questo array.