Chaîne de pointeur et tableau de caractères en c

Vous pouvez initialiser un tableau lorsque vous déclarez, comme ceci:

int n[5] = { 0, 1, 2, 3, 4 };
char c[5] = { 'd', 'a', 't', 'a', '
int n[5] = { 0, 1, 2, 3, 4 };
char c[5] = { 'd', 'a', 't', 'a', '\0' };
' };

Mais depuis que nous avons généralement de traiter des tableaux de char comme des chaînes de caractères, C) permet à un cas particulier:

char c[5] = "data";  //Terminating null character is added.

Cependant, une fois que vous avez déclaré un tableau, vous ne pouvez pas réaffecter. Pourquoi? Envisager une affectation comme

char *my_str = "foo";  //Declare and initialize a char pointer.
my_str = "bar";        //Change its value.

La première ligne déclare un pointeur de char et "objectifs" à la première lettre en foo. Depuis foo est une constante de chaîne, il se trouve quelque part dans la mémoire avec toutes les autres constantes. Lorsque vous réaffectez le pointeur, vous êtes d'affecter une nouvelle valeur: l'adresse de bar. Mais la chaîne d'origine, foo reste inchangé. Vous avez déplacé le pointeur, mais je n'ai pas modifié les données.

Lorsque vous déclarez un tableau, toutefois, vous n'êtes pas déclarer un pointeur à tous. Vous êtes à la réservation d'une certaine quantité de mémoire et de lui donner un nom. De sorte que la ligne

char c[5] = "data";

commence avec la constante de chaîne data, puis alloue 5 nouveaux octets, les appelle c, et des copies de la chaîne. Vous pouvez accès les éléments de la matrice exactement comme si vous aviez déclaré un pointeur vers eux; les tableaux et les pointeurs sont (pour la plupart des besoins) interchangeables.

Mais comme les tableaux ne sont pas des pointeurs, vous ne pouvez pas réaffecter.

Vous ne pouvez pas faire c "point" n'importe où d'autre, parce que ce n'est pas un pointeur, c'est le nom d'une zone de mémoire.

Vous peut modifier la valeur de la chaîne, soit un caractère à la fois, ou par l'appel d'une fonction comme strcpy():

c[3] = 'e';       //Now c = "date", or 'd', 'a', 't', 'e', '
c[3] = 'e';       //Now c = "date", or 'd', 'a', 't', 'e', '\0'
strcpy(c, "hi");  //Now c = 'h', 'i', '\0', 'e', '\0'
strcpy(c, "too long!") //Error: overflows into memory we don't own.
'
strcpy(c, "hi");  //Now c = 'h', 'i', '
c[3] = 'e';       //Now c = "date", or 'd', 'a', 't', 'e', '\0'
strcpy(c, "hi");  //Now c = 'h', 'i', '\0', 'e', '\0'
strcpy(c, "too long!") //Error: overflows into memory we don't own.
', 'e', '
c[3] = 'e';       //Now c = "date", or 'd', 'a', 't', 'e', '\0'
strcpy(c, "hi");  //Now c = 'h', 'i', '\0', 'e', '\0'
strcpy(c, "too long!") //Error: overflows into memory we don't own.
'
strcpy(c, "too long!") //Error: overflows into memory we don't own.

L'Efficacité De Pointe

Note, également, que l'initialisation d'un tableau est en général une copie des données: la chaîne d'origine est copié à partir de la constante de la zone de la zone de données, où votre programme peut changer. Bien sûr, cela signifie que vous êtes en utilisant deux fois plus de mémoire que vous pouvez penser. Vous pouvez éviter la copie et généralement économiser de la mémoire par la déclaration d'un pointeur à la place. Que les feuilles de la chaîne dans la constante de la zone et alloue suffisamment de mémoire pour un pointeur, quelle que soit la longueur de la chaîne.

OriginalL'auteur Adam Liss

Vous ne pouvez pas directement attribuer une valeur à un tableau de type (par exemple, votre tableau de dix chars name4). Pour le compilateur, name4 est un "tableau" et vous ne pouvez pas utiliser l'assignation = opérateur d'écrire sur un tableau avec une chaîne littérale.

Pour réellement se déplacer le contenu de la chaîne "Apple" dans les dix tableau d'octets que vous avez alloué pour elle (name4), vous devez utiliser strcpy() ou quelque chose du genre.

Ce que vous faites avec name3 est assez différente. Il est créé comme un char * et initialisé à la poubelle, ou zéro (vous ne savez pas sûr qu'à ce point). Ensuite, vous affectez dans la emplacement de la chaîne statique "Apple". C'est une chaîne qui vit dans la mémoire en lecture seule, et la tentative d'écriture dans la mémoire de l' name3 pointeur de points ne pourra jamais réussir.

Sur cette base, vous pouvez supposer que la dernière instruction tente d'affecter l'emplacement de la mémoire d'une chaîne statique pour quelque chose d'ailleurs qui représente une collection de 10 chars. La langue ne vous fournit pas avec pré-déterminé de la façon d'effectuer cette tâche.

C'est ici que réside sa puissance.

OriginalL'auteur Steven Lu

Je pense que cela va aider à éclaircir aussi:

int main() {
    char* ptr   = "Hello";
    char  arr[] = "Goodbye";

    //These both work, as expected:
    printf("%s\n", ptr);
    printf("%s\n", arr);
    printf("%s\n", &arr);   //also works!

    printf("ptr  = %p\n", ptr);
    printf("&ptr = %p\n", &ptr);
    printf("arr  = %p\n", arr);
    printf("&arr = %p\n", &arr);

    return 0;
 }

De sortie:

Hello
Goodbye
Goodbye
ptr  = 0021578C         
&ptr = 0042FE2C         
arr  = 0042FE1C         \__ Same!
&arr = 0042FE1C         /

Nous voyons donc que arr == &arr. Puisque c'est un tableau, le compilateur sait que vous allez toujours vouloir l'adresse du premier octet, indépendamment de la façon dont il est utilisé.

arr est un tableau de 7+1 octets, qui sont sur le pile de main(). Le compilateur génère des instructions tho réserve de ces octets, puis le remplir avec des "au Revoir". Il n'y a pas de pointeur!

ptr d'autre part, est un pointeur, un entier de 4 octets, également sur la pile. C'est pourquoi &ptr est très proche de &arr. Mais ce qu'il points, est un static string ("Bonjour"), c'est-off dans la lecture seule section de l'exécutable (c'est pourquoi ptr's la valeur est très différente de ce numéro).

OriginalL'auteur Jonathon Reinhart