Comment copier un tableau de caractères dans C?

En C, j’ai deux tableaux de caractères:

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

Comment copier la valeur de array1 à array2 ? Puis-je faire ceci: array2 = array1 ?

Vous ne pouvez pas faire directement array1 = array2 . Car dans ce cas, vous manipuleriez les adresses ( char * ) des tableaux et non leurs valeurs.

Pour ce genre de situation, il est recommandé d’utiliser strncpy pour éviter un débordement de mémoire tampon , surtout si array1 est rempli à partir d’une entrée utilisateur (clavier, réseau, etc.). Ainsi:

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

Comme @prof. Falken mentionné dans un commentaire, strncpy peut être mauvais . Assurez-vous que votre tampon cible est suffisamment grand pour contenir le tampon source (y compris le \0 à la fin de la chaîne).

Si vous voulez vous prémunir contre les chaînes non terminées, qui peuvent causer toutes sortes de problèmes, copiez votre chaîne comme ceci:

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

Cette dernière ligne est en fait importante, car strncpy() ne met pas toujours à strncpy() chaînes. (Si le tampon de destination est trop petit pour contenir toute la chaîne source, sntrcpy () ne mettra pas fin à la chaîne de destination.)

La page de manuel de strncpy () indique même “Attention: S’il n’y a pas d’octet nul parmi les n premiers octets de src, la chaîne placée dans dest ne sera pas terminée par un caractère nul.”

La raison pour laquelle strncpy () se comporte de cette façon un peu étrange est qu’elle n’était pas conçue à l’origine comme un moyen sûr de copier des chaînes.

Une autre méthode consiste à utiliser snprintf () pour remplacer strcpy ():

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

(Merci jxh pour le conseil.)

Si vos tableaux ne sont pas des tableaux, utilisez: memcpy(array2, array1, sizeof(array2));

Vous ne pouvez pas affecter de tableaux, les noms sont des constantes qui ne peuvent pas être modifiées.

Vous pouvez copier le contenu avec:

 strcpy(array2, array1); 

en supposant que la source est une chaîne valide et que la destination est suffisamment grande, comme dans votre exemple.

Comme d’autres l’ont noté, les chaînes sont copiées avec strcpy() ou ses variantes. Dans certains cas, vous pouvez également utiliser snprintf() .

Vous ne pouvez affecter des tableaux que comme vous le souhaitez dans le cadre d’une affectation de structure:

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

Si vos tableaux sont passés à une fonction, il apparaîtra que vous êtes autorisé à les atsortingbuer, mais ceci est juste un accident de la sémantique. En C, un tableau décroît en un type de pointeur avec la valeur de l’adresse du premier membre du tableau, et ce pointeur est ce qui est passé. Donc, le paramètre de votre tableau dans votre fonction n’est qu’un simple pointeur. L’affectation est juste une affectation de pointeur:

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

Le tableau lui-même rest inchangé après le retour de la fonction.

Cette sémantique de “décroissance à la valeur du pointeur” pour les tableaux est la raison pour laquelle l’affectation ne fonctionne pas. La valeur l a le type de tableau, mais la valeur r est le type de pointeur décomposé, donc l’affectation se fait entre des types incompatibles.

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

Pour ce qui est de savoir pourquoi la sémantique “decay to pointer value” a été introduite, cela visait à obtenir une compatibilité de code source avec le prédécesseur de C. Vous pouvez lire Le développement du langage C pour plus de détails.

ça devrait ressembler à ça:

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

n’est pas pris en charge dans c. Vous devez utiliser des fonctions comme strcpy () pour le faire.

Je recommande d’utiliser memcpy () pour copier les données. De même, si nous array2 = array1 un tampon à un autre comme array2 = array1 , les deux tableaux ont la même mémoire et tout changement de l’arrérage1 dévie également dans array2. Mais nous utilisons memcpy, les deux tampons ont un tableau différent. Je recommande memcpy () car strcpy et la fonction associée ne copient pas le caractère NULL.

c fonctions ci-dessous uniquement … c ++ vous devez faire un tableau de caractères, puis utiliser une copie de chaîne, puis utiliser les fonctions de chaîne de caractères tokenizor … c ++ rend beaucoup plus difficile de faire

 #include  #include  #include  #define TRUE 1 #define FALSE 0 typedef int Bool; using namespace std; Bool PalTrueFalse(char str[]); int main(void) { char ssortingng[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: "< 

pour les types entiers

 #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") 

Vous ne pouvez pas affecter de tableaux pour les copier. La façon dont vous pouvez copier le contenu de l’un dans un autre dépend de plusieurs facteurs:

Pour les tableaux de caractères, si vous savez que le tableau source est à null null et que le tableau de destination est suffisamment grand pour la chaîne du tableau source, y compris le terminateur null, utilisez strcpy() :

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

Si vous ne savez pas si le tableau de destination est suffisamment grand, mais que la source est une chaîne C et que vous souhaitez que la destination soit une chaîne C correcte, utilisez snprinf() :

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

Si le tableau source n’est pas nécessairement terminé par null, mais que vous savez que les deux tableaux ont la même taille, vous pouvez utiliser memcpy :

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