web-dev-qa-db-fra.com

Est-il possible de convertir char [] en char * en C?

Je fais un travail où nous devons lire une série de chaînes d'un fichier dans un tableau. Je dois appeler un algorithme de chiffrement sur le tableau (chiffrement transpose des tableaux 2D). Ainsi, au début, j'ai mis toutes les informations du fichier dans un tableau 2D, mais j'ai eu beaucoup de problèmes avec les types en conflit dans le reste de mon code (en essayant en particulier de définir char [] à char *). J'ai donc décidé de passer à un tableau de pointeurs, ce qui simplifie grandement la tâche dans la plupart de mes codes.

Mais maintenant, je dois convertir char * en char [] et inversement, mais je ne peux pas le comprendre. Je n'ai rien trouvé sur google. Je commence à me demander si c'est même possible.

cchar
50
tparf

Il semble que vous soyez confus entre les pointeurs et les tableaux. Les pointeurs et les tableaux (dans ce cas, char * Et char []) Sont pas la même chose.

  • Un tableau char a[SIZE] Indique que la valeur à l'emplacement de a est un tableau de longueur SIZE
  • Un pointeur char *a; Indique que la valeur à l'emplacement de a est un pointeur sur un char. Cela peut être combiné avec l'arithmétique de pointeur pour se comporter comme un tableau (par exemple, a[10] A 10 entrées depuis où a points)

En mémoire, cela ressemble à ceci (exemple tiré de la FAQ ):

 char a[] = "hello";  // array

   +---+---+---+---+---+---+
a: | h | e | l | l | o |\0 |
   +---+---+---+---+---+---+

 char *p = "world"; // pointer

   +-----+     +---+---+---+---+---+---+
p: |  *======> | w | o | r | l | d |\0 |
   +-----+     +---+---+---+---+---+---+

Il est facile de ne pas comprendre la différence entre les pointeurs et les tableaux, car dans de nombreux cas, une référence à un tableau "se désintègre" en pointeur vers son premier élément. Cela signifie que dans de nombreux cas (par exemple, lorsqu'ils sont passés à un appel de fonction), les tableaux deviennent des pointeurs. Si vous souhaitez en savoir plus, cette section du C FAQ décrit les différences en détail) .

Une différence pratique majeure est que le compilateur sait combien de temps un tableau est. En utilisant les exemples ci-dessus:

char a[] = "hello";  
char *p =  "world";  

sizeof(a); // 6 - one byte for each character in the string,
           // one for the '\0' terminator
sizeof(p); // whatever the size of the pointer is
           // probably 4 or 8 on most machines (depending on whether it's a 
           // 32 or 64 bit machine)

Sans voir votre code, il est difficile de recommander le meilleur plan d'action, mais je suppose que le fait d'utiliser des pointeurs partout résoudra les problèmes que vous rencontrez actuellement. Prenez note que maintenant:

  • Vous devrez initialiser la mémoire là où se trouvaient les tableaux. Par exemple, char a[10]; Deviendra char *a = malloc(10 * sizeof(char));, suivi d'un contrôle que a != NULL. Notez que vous n'avez pas réellement besoin de dire sizeof(char) dans ce cas, car sizeof(char) est défini à 1. Je l'ai laissé pour compléter.

  • Partout où vous aviez auparavant sizeof(a) pour la longueur du tableau, vous devrez remplacer la longueur de la mémoire allouée (si vous utilisez des chaînes, vous pouvez utiliser strlen(), qui compte jusqu'à le '\0').

  • Vous aurez besoin de faire un appel correspondant à free() pour chaque appel à malloc(). Cela indique à l'ordinateur que vous avez terminé d'utiliser la mémoire demandée avec malloc(). Si votre pointeur est a, écrivez simplement free(a); à un endroit du code où vous savez que vous n’avez plus besoin de quoi que ce soit que a pointe vers.

Comme une autre réponse l’a souligné, si vous voulez obtenir l’adresse du début d’un tableau, vous pouvez utiliser:

char* p = &a[0]

Vous pouvez le lire comme suit: "le pointeur sur caractères p devient l'adresse de l'élément [0] De a".

101
Timothy Jones

Si vous avez char[] c Alors vous pouvez faire char* d = &c[0] Et accéder à l'élément c [1] en faisant *(d+1), etc.

14
dave

Vous n'avez pas besoin de les déclarer en tant que tableaux si vous souhaitez les utiliser comme pointeurs. Vous pouvez simplement référencer des pointeurs comme s'il s'agissait de tableaux multidimensionnels. Créez-le simplement en tant que pointeur sur un pointeur et utilisez malloc:

int i;
int M=30, N=25;
int ** buf;
buf = (int**) malloc(M * sizeof(int*));
for(i=0;i<M;i++)
    buf[i] = (int*) malloc(N * sizeof(int));

et ensuite vous pouvez référencer buf[3][5] ou peu importe.

2
jcai