Quelle est la différence entre un tableau de caractères et un pointeur de caractères en C?

J'essaie de comprendre les pointeurs en C mais je suis actuellement confus avec ce qui suit:

• char *p = "hello"

  Il s'agit d'un pointeur de caractère pointant sur le tableau de caractères, commençant à h .

• char p[] = "hello"

  Ceci est un tableau qui stocke bonjour .

Quelle est la différence lorsque je passe ces deux variables dans cette fonction?

void printSomething(char *p)
{
    printf("p: %s",p);
}

char*et char[] sont de types différents , mais ce n'est pas immédiatement apparent dans tous les cas. Cela est dû au fait que les tableaux se désintègrent en pointeurs , ce qui signifie que si une expression de type char[]est fournie là où l'un de type char*est attendu, le compilateur convertit automatiquement le tableau en un pointeur vers son premier élément.

Votre exemple de fonction printSomethingattend un pointeur, donc si vous essayez de lui passer un tableau comme ceci:

char s[10] = "hello";
printSomething(s);

Le compilateur prétend que vous avez écrit ceci:

char s[10] = "hello";
printSomething(&s[0]);

Voyons voir:

#include <stdio.h>
#include <string.h>

int main()
{
    char *p = "hello";
    char q[] = "hello"; // no need to count this

    printf("%zu\n", sizeof(p)); // => size of pointer to char -- 4 on x86, 8 on x86-64
    printf("%zu\n", sizeof(q)); // => size of char array in memory -- 6 on both

    // size_t strlen(const char *s) and we don't get any warnings here:
    printf("%zu\n", strlen(p)); // => 5
    printf("%zu\n", strlen(q)); // => 5

    return 0;
}

foo * et foo [] sont de types différents et ils sont traités différemment par le compilateur (pointeur = adresse + représentation du type du pointeur, tableau = pointeur + longueur facultative du tableau, si connu, par exemple, si le tableau est alloué statiquement ), les détails peuvent être trouvés dans la norme. Et au niveau de l'exécution aucune différence entre eux (en assembleur, enfin presque, voir ci-dessous).

En outre, il existe une question connexe dans la FAQ C :

Q : Quelle est la différence entre ces initialisations?

char a[] = "string literal";   
char *p  = "string literal";   

Mon programme se bloque si j'essaie d'attribuer une nouvelle valeur à p [i].

R : Un littéral de chaîne (le terme formel pour une chaîne entre guillemets doubles dans la source C) peut être utilisé de deux manières légèrement différentes:

1. En tant qu'initialiseur d'un tableau de char, comme dans la déclaration de char a [], il spécifie les valeurs initiales des caractères de ce tableau (et, si nécessaire, sa taille).
2. Partout ailleurs, il se transforme en un tableau de caractères statique sans nom, et ce tableau sans nom peut être stocké dans une mémoire en lecture seule, et qui ne peut donc pas nécessairement être modifié. Dans un contexte d'expression, le tableau est converti immédiatement en un pointeur, comme d'habitude (voir section 6), donc la deuxième déclaration initialise p pour pointer vers le premier élément du tableau sans nom.

Certains compilateurs ont un commutateur contrôlant si les littéraux de chaîne sont inscriptibles ou non (pour la compilation de l'ancien code), et certains peuvent avoir des options pour que les littéraux de chaîne soient formellement traités comme des tableaux de const char (pour une meilleure capture des erreurs).

Voir également les questions 1.31, 6.1, 6.2, 6.8 et 11.8b.

Références: K & R2 Sec. 5,5 p. 104

ISO Sec. 6.1.4, Sec. 6.5.7

Justification Sec. 3.1.4

H&S Sec. 2.7.4 p. 31-2

Quelle est la différence entre un tableau de caractères et un pointeur de caractères en C?

C99 N1256 draft

Il existe deux utilisations différentes des littéraux de chaîne de caractères:

1. Initialiser char[]:

   char c[] = "abc";      

   C'est "plus magique", et décrit au 6.7.8 / 14 "Initialisation":

   Un tableau de type caractère peut être initialisé par une chaîne de caractères littérale, éventuellement entourée d'accolades. Les caractères successifs du littéral de chaîne de caractères (y compris le caractère nul de fin s'il y a de la place ou si le tableau est de taille inconnue) initialisent les éléments du tableau.

   Ce n'est donc qu'un raccourci pour:

   char c[] = {'a', 'b', 'c', '\0'};

   Comme tout autre tableau régulier, cpeut être modifié.

2. Partout ailleurs: il génère un:

   • anonyme
   • tableau de caractères Quel est le type de littéraux de chaîne en C et C ++?
   • avec stockage statique
   • qui donne UB (comportement indéfini) en cas de modification

   Donc, quand vous écrivez:

   char *c = "abc";

   Ceci est similaire à:

   /* __unnamed is magic because modifying it gives UB. */
   static char __unnamed[] = "abc";
   char *c = __unnamed;

   Notez la conversion implicite de char[]à char *, qui est toujours légale.

   Ensuite, si vous modifiez c[0], vous modifiez également __unnamed, qui est UB.

   Ceci est documenté en 6.4.5 "Littéraux de chaîne":

   5 Dans la phase de traduction 7, un octet ou un code de valeur zéro est ajouté à chaque séquence de caractères multi-octets résultant d'un ou plusieurs littéraux de chaîne. La séquence de caractères multi-octets est ensuite utilisée pour initialiser un tableau de durée et de longueur de stockage statique juste suffisant pour contenir la séquence. Pour les littéraux de chaîne de caractères, les éléments du tableau ont le type char et sont initialisés avec les octets individuels de la séquence de caractères multi-octets [...]

   6 Il n'est pas précisé si ces tableaux sont distincts à condition que leurs éléments aient les valeurs appropriées. Si le programme tente de modifier un tel tableau, le comportement n'est pas défini.

6.7.8 / 32 "Initialisation" donne un exemple direct:

EXEMPLE 8: La déclaration

char s[] = "abc", t[3] = "abc";

définit les objets de tableau de caractères "simples" sett dont les éléments sont initialisés avec des littéraux de chaîne de caractères.

Cette déclaration est identique à

char s[] = { 'a', 'b', 'c', '\0' },
t[] = { 'a', 'b', 'c' };

Le contenu des tableaux est modifiable. En revanche, la déclaration

char *p = "abc";

définit pavec le type "pointeur sur char" et l'initialise pour pointer vers un objet de type "tableau de char" de longueur 4 dont les éléments sont initialisés avec une chaîne de caractères littérale. Si une tentative est faite pour pmodifier le contenu du tableau, le comportement n'est pas défini.

Mise en œuvre de GCC 4.8 x86-64 ELF

Programme:

#include <stdio.h>

int main(void) {
    char *s = "abc";
    printf("%s\n", s);
    return 0;
}

Compiler et décompiler:

gcc -ggdb -std=c99 -c main.c
objdump -Sr main.o

La sortie contient:

 char *s = "abc";
8:  48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
f:  00 
        c: R_X86_64_32S .rodata

Conclusion: GCC le stocke char*dans la .rodatasection, pas dans .text.

Si nous faisons de même pour char[]:

 char s[] = "abc";

on obtient:

17:   c7 45 f0 61 62 63 00    movl   $0x636261,-0x10(%rbp)

donc il est stocké dans la pile (par rapport à %rbp).

Notez cependant que le script de l'éditeur de liens par défaut place .rodataet .textdans le même segment, qui a une autorisation d'exécution mais pas d'écriture. Cela peut être observé avec:

readelf -l a.out

qui contient:

 Section to Segment mapping:
  Segment Sections...
   02     .text .rodata

Vous n'êtes pas autorisé à modifier le contenu d'une constante de chaîne, ce à quoi ppointe le premier . Le second pest un tableau initialisé avec une constante chaîne, et vous pouvez changer son contenu.

Pour des cas comme celui-ci, l'effet est le même: vous finissez par passer l'adresse du premier caractère dans une chaîne de caractères.

Mais les déclarations ne sont évidemment pas les mêmes.

Ce qui suit met de côté la mémoire pour une chaîne et également un pointeur de caractère, puis initialise le pointeur pour pointer vers le premier caractère de la chaîne.

char *p = "hello";

Alors que ce qui suit met de côté la mémoire juste pour la chaîne. Il peut donc utiliser moins de mémoire.

char p[10] = "hello";

Pour autant que je me souvienne, un tableau est en fait un groupe de pointeurs. Par exemple

p[1]== *(&p+1)

est une vraie déclaration

De l' APUE , section 5.14:

char    good_template[] = "/tmp/dirXXXXXX"; /* right way */
char    *bad_template = "/tmp/dirXXXXXX";   /* wrong way*/

... Pour le premier modèle, le nom est alloué sur la pile, car nous utilisons une variable de tableau. Pour le deuxième nom, cependant, nous utilisons un pointeur. Dans ce cas, seule la mémoire du pointeur lui-même réside sur la pile; le compilateur organise le stockage de la chaîne dans le segment en lecture seule de l'exécutable. Lorsque la mkstempfonction tente de modifier la chaîne, une erreur de segmentation se produit.

Le texte cité correspond à l'explication de @Ciro Santilli.

char p[3] = "hello"? devrait se char p[6] = "hello"rappeler qu'il y a un caractère '\ 0' à la fin d'une "chaîne" en C.

quoi qu'il en soit, le tableau en C n'est qu'un pointeur vers le premier objet d'un objet à ajuster dans la mémoire. les seuls différents sont en sémantique. tandis que vous pouvez modifier la valeur d'un pointeur pour pointer vers un emplacement différent dans la mémoire, un tableau, une fois créé, pointera toujours vers le même emplacement.
également lorsque vous utilisez un tableau, les «nouveaux» et «supprimer» sont automatiquement effectués pour vous.