Come copiare un array di caratteri in C?

In C, ho due array di caratteri:

char array1[18] = "abcdefg"; char array2[18]; 

Come copiare il valore di array1 in array2 ? Posso solo fare questo: array2 = array1 ?

Non puoi fare direttamente array1 = array2 . Perché in questo caso dovresti manipolare gli indirizzi ( char * ) degli array e non i loro valori.

Per questo tipo di situazione, si raccomanda di usare strncpy per evitare un overflow del buffer , specialmente se array1 è compilato da input dell’utente (tastiera, rete, ecc.). Così:

 // Will copy 18 characters from array1 to array2 strncpy(array2, array1, 18); 

Come @Prof. Falken citato in un commento, strncpy può essere malvagio . Assicurati che il tuo buffer di destinazione sia abbastanza grande da contenere il buffer di origine (incluso il \0 alla fine della stringa).

Se vuoi evitare stringhe non terminate, che possono causare tutti i tipi di problemi, copia la stringa in questo modo:

 char array1[18] = {"abcdefg"}; char array2[18]; size_t destination_size = sizeof (array2); strncpy(array2, array1, destination_size); array2[destination_size - 1] = '\0'; 

Quest’ultima riga è davvero importante, perché strncpy() non sempre termina le stringhe null . (Se il buffer di destinazione è troppo piccolo per contenere l’intera stringa di origine, sntrcpy () non annullerà la stringa di destinazione.)

La manpage per strncpy () afferma anche “Attenzione: se non esiste un byte null tra i primi n byte di src, la stringa inserita in dest non sarà terminata con null.”

La ragione per cui strncpy () si comporta in un modo un po ‘strano, è perché in realtà non era originariamente inteso come un modo sicuro per copiare le stringhe.

Un altro modo è usare snprintf () come sostituto sicuro per strcpy ():

 snprintf(array2, destination_size, "%s", array1); 

(Grazie a jxh per il suggerimento.)

Se i tuoi array non sono array di stringhe, usa: memcpy(array2, array1, sizeof(array2));

Non è ansible assegnare array, i nomi sono costanti che non possono essere modificati.

Puoi copiare il contenuto , con:

 strcpy(array2, array1); 

supponendo che l’origine sia una stringa valida e che la destinazione sia sufficientemente grande, come nel tuo esempio.

Come altri hanno notato, le stringhe vengono copiate con strcpy() o le sue varianti. In alcuni casi, è ansible utilizzare anche snprintf() .

Puoi solo assegnare gli array nel modo che desideri come parte di un assegnamento di struttura:

 typedef struct { char a[18]; } array; array array1 = { "abcdefg" }; array array2; array2 = array1; 

Se i tuoi array vengono passati a una funzione, sembrerà che tu sia autorizzato ad assegnarli, ma questo è solo un incidente della semantica. In C, un array decadrà a un tipo di puntatore con il valore dell’indirizzo del primo membro dell’array, e questo puntatore è ciò che viene passato. Quindi, il parametro dell’array nella tua funzione è in realtà solo un puntatore. L’assegnazione è solo un’assegnazione puntatore:

 void foo (char x[10], char y[10]) { x = y; /* pointer assignment! */ puts(x); } 

L’array rimane invariato dopo il ritorno dalla funzione.

Questa semantica “decay to pointer value” per gli array è la ragione per cui l’assegnazione non funziona. Il valore l ha il tipo di matrice, ma il valore r è il tipo di puntatore decaduto, quindi l’assegnazione è tra tipi incompatibili.

 char array1[18] = "abcdefg"; char array2[18]; array2 = array1; /* fails because array1 becomes a pointer type, but array2 is still an array type */ 

Per quanto riguarda il motivo per cui è stata introdotta la semantica “decay to pointer value”, si trattava di ottenere una compatibilità del codice sorgente con il predecessore di C. Potete leggere lo sviluppo del linguaggio C per i dettagli.

Dovrebbe sembrare come questo:

 void cstringcpy(char *src, char * dest) { while (*src) { *(dest++) = *(src++); } *dest = '\0'; } ..... char src[6] = "Hello"; char dest[6]; cstringcpy(src, dest); 
 array2 = array1; 

non è supportato in c. Devi usare funzioni come strcpy () per farlo.

Raccomando di usare memcpy () per copiare i dati. Inoltre, se assegniamo un buffer a un altro come array2 = array1 , entrambi gli array hanno la stessa memoria e qualsiasi cambiamento nell’array1 si deforma anche nell’array2. Ma usiamo memcpy, entrambi i buffer hanno array diversi. Raccomando memcpy () perché strcpy e la relativa funzione non copiano il carattere NULL.

c funziona di seguito solo … c ++ devi fare array di caratteri quindi usare una copia di stringa quindi usare le funzioni di stringa di tokenizor … c ++ ha reso molto più difficile fare anythng

 #include  #include  #include  #define TRUE 1 #define FALSE 0 typedef int Bool; using namespace std; Bool PalTrueFalse(char str[]); int main(void) { char string[1000], ch; int i = 0; cout<<"Enter a message: "; while((ch = getchar()) != '\n') //grab users input string untill { //Enter is pressed if (!isspace(ch) && !ispunct(ch)) //Cstring functions checking for { //spaces and punctuations of all kinds string[i] = tolower(ch); i++; } } string[i] = '\0'; //hitting null deliminator once users input cout<<"Your string: "< 

per i tipi interi

 #include  int array1[10] = {0,1,2,3,4,5,6,7,8,9}; int array2[10]; memcpy(array2,array1,sizeof(array1)); // memcpy("destination","source","size") 

Non è ansible assegnare gli array per copiarli. Come è ansible copiare i contenuti di uno in un altro dipende da più fattori:

Per gli array di char , se si conosce che l’array di origine è terminato con null e l’array di destinazione è sufficientemente grande per la stringa nell’array di origine, incluso il terminatore nullo, utilizzare strcpy() :

 #include  char array1[18] = "abcdefg"; char array2[18]; ... strcpy(array2, array1); 

Se non si sa se la matrice di destinazione è sufficientemente grande, ma la sorgente è una stringa C e si desidera che la destinazione sia una stringa C appropriata, utilizzare snprinf() :

 #include  char array1[] = "a longer string that might not fit"; char array2[18]; ... snprintf(array2, sizeof array2, "%s", array1); 

Se la matrice di origine non è necessariamente nullo, ma sai che entrambi gli array hanno la stessa dimensione, puoi usare memcpy :

 #include  char array1[28] = "a non null terminated string"; char array2[28]; ... memcpy(array2, array1, sizeof array2);