cancellare un array di caratteri c

Ho pensato che impostando il primo elemento su un null sarebbe stato cancellato l'intero contenuto di un array di caratteri.

char my_custom_data[40] = "Hello!";
my_custom_data[0] = '\0';

Tuttavia, questo imposta solo il primo elemento su null.

o

my_custom_data[0] = 0; 

piuttosto che usare memset, ho pensato che i 2 esempi sopra dovrebbero cancellare tutti i dati.

Dipende da come si desidera visualizzare l'array. Se stai visualizzando l'array come una serie di caratteri, l'unico modo per cancellare i dati è toccare ogni voce. memsetè probabilmente il modo più efficace per ottenere questo risultato.

D'altra parte, se si sceglie di visualizzarlo come una stringa con terminazione null C / C ++, l'impostazione del primo byte su 0 cancellerà effettivamente la stringa.

Un array in C è solo una posizione di memoria, quindi l' my_custom_data[0] = '\0';assegnazione imposta semplicemente il primo elemento a zero e lascia gli altri elementi intatti.

Se vuoi cancellare tutti gli elementi dell'array, dovrai visitare ogni elemento. Questo è ciò che memsetserve:

memset(&arr[0], 0, sizeof(arr));

Questo è generalmente il modo più veloce per occuparsene. Se puoi usare C ++, considera invece std :: fill:

char *begin = &arr;
char *end = begin + sizeof(arr);
std::fill(begin, end, 0);

Perché pensi che l'impostazione di un singolo elemento cancelli l'intero array? In C, soprattutto, accade poco senza che il programmatore lo programmi esplicitamente. Se imposti il ​​primo elemento su zero (o qualsiasi valore), hai fatto esattamente questo e nient'altro.

Durante l'inizializzazione è possibile impostare un array su zero:

char mcd[40] = {0}; /* sets the whole array */

Altrimenti, non conosco altra tecnica oltre al memset o qualcosa di simile.

Uso:

memset(my_custom_data, 0, sizeof(my_custom_data));

O:

memset(my_custom_data, 0, strlen(my_custom_data));

Prova il codice seguente:

void clean(char *var) {
    int i = 0;
    while(var[i] != '\0') {
        var[i] = '\0';
        i++;
    }
}

Perché non usare memset()? Ecco come farlo.

L'impostazione del primo elemento lascia intatto il resto della memoria, ma le funzioni str tratteranno i dati come vuoti.

Pls trova di seguito dove ho spiegato con i dati nella matrice dopo il caso 1 e il caso 2.

char sc_ArrData[ 100 ];
strcpy(sc_ArrData,"Hai" );

Caso 1:

sc_ArrData[0] = '\0';

Risultato:

-   "sc_ArrData"
[0] 0 ''
[1] 97 'a'
[2] 105 'i'
[3] 0 ''

Caso 2:

memset(&sc_ArrData[0], 0, sizeof(sc_ArrData));

Risultato:

-   "sc_ArrData"
[0] 0 ''
[1] 0 ''
[2] 0 ''
[3] 0 ''

Sebbene l'impostazione del primo argomento su NULL risolva il problema, è consigliabile utilizzare memset

No. Tutto quello che stai facendo è impostare il primo valore su "\ 0" o 0.

Se stai lavorando con stringhe con terminazione nulla, nel primo esempio otterrai un comportamento che imita ciò che ti aspetti, tuttavia la memoria è ancora impostata.

Se vuoi cancellare la memoria senza usare memset, usa un ciclo for.

Dovresti usare memset. L'impostazione solo del primo elemento non funzionerà, è necessario impostare tutti gli elementi - in caso contrario, come potresti impostare solo il primo elemento su 0?

Scrivere un carattere nullo sul primo carattere fa proprio questo. Se lo consideri come una stringa, il codice che obbedisce al carattere di terminazione null lo tratterà come una stringa nulla, ma non è la stessa cosa che cancellare i dati. Se vuoi effettivamente cancellare i dati dovrai usare memset.

Di solito faccio così:

memset(bufferar, '\0', sizeof(bufferar));

Ho pensato che impostando il primo elemento su un null sarebbe stato cancellato l'intero contenuto di un array di caratteri.

Non è corretto come hai scoperto

Tuttavia, questo imposta solo il primo elemento su null.

Esattamente!

È necessario utilizzare memset per cancellare tutti i dati, non è sufficiente impostare una delle voci su null.

Tuttavia, se impostare un elemento dell'array su null significa qualcosa di speciale (ad esempio quando si utilizza una stringa di terminazione null in) potrebbe essere sufficiente impostare il primo elemento su null. In questo modo qualsiasi utente dell'array capirà che è vuoto anche se l'array include ancora i vecchi caratteri in memoria

imposta il primo elemento su NULL. la stampa dell'array di caratteri non ti restituirà nulla.

Che ne dici di quanto segue:

bzero(my_custom_data,40);

void clearArray (char *input[]){
    *input = ' '; 
}

Prova quanto segue:

strcpy(my_custom_data,"");