Programmation C: comment travailler pointeur mathématiques dans un tableau

Qu'advient-il lorsque vous incrémenter un pointeur dans la programmation C? Dire que variable pointeur dave référence à une variable à l'adresse mémoire 0x8000. Si oui, envisagez cette déclaration:

dave ++ -

Quelle serait la valeur de pointeur dave être?

Votre premier réflexe serait de dire que Dave serait incrémenté de 1, ce qui est correct. Mais le résultat du calcul ne soit pas 0x8001. Voilà parce que l'adresse stockée dans une variable de pointeur est incrémenté d'une unité, pas par un chiffre.

Qu'est-ce qu'une unité?

Cela dépend du type de variable. Si Dave pointeur est un pointeur char, en effet la nouvelle adresse pourrait être 0x8001. Mais si Dave était un int ou un flotteur, la nouvelle adresse serait le même que

0x8000 + sizeof (int)

ou

0x8000 + sizeof (float)

Sur la plupart des systèmes, un int est de 4 octets, de sorte que vous pouvez deviner que Dave serait égale à 0x8004 après l'opération d'incrémentation. Mais pourquoi deviner quand vous pouvez coder?

Les tableaux et les Pointer Math illustre un programme simple, quelque chose que vous pourriez coder sans utiliser des pointeurs: Remplir un tableau de int avec des valeurs de 1 à 10, puis afficher le tableau et ses valeurs. Mais en tableaux et les Pointer Math, un pointeur est utilisé pour remplir le tableau.

RÉSEAUX ET POINTER MATH

#include int main () {int numéros [10] -int x-int * pn pn = Numéros / * initialiser pointeur * // * Remplissez tableau * / for (x = 0 XLT; 10 x ++) {* pn = x + 1-pn ++ -} / * tableau d'affichage * / for (x = 0 XLT; 10 x ++) printf ("nombres [% d] =% d n", x + 1, les numéros [x] ) -retour (0) -}

Ligne 7 déclare le PN de pointeur, et la ligne 9 initialise. La est pas nécessaire ici parce que les nombres est un tableau, pas une variable individuelle. À ce moment, le pointeur contient l'adresse de base de la matrice. Gardez à l'esprit que le tableau est vide.

La boucle pendant au Lignes 12 à 16 remplit le tableau de nombres. Le premier élément est rempli à la ligne 14 en utilisant la notation de Peeker pour pointeur pn. Puis, à la ligne 15, pointeur pn est incrémenté d'une unité. Il pointe désormais à l'élément suivant dans le tableau, et les répétitions de la boucle.

Exercice 1: Copiez le code source à partir de tableaux et Pointer Math dans votre éditeur. Construire et exécuter.

Exercice 2: Modifier votre code source de l'exercice 1 de sorte que l'adresse de chaque élément dans le tableau est affiché avec sa valeur.

Dans la sortie de l'exercice 2, vous devriez voir que chaque adresse est séparé par 4 octets (en supposant que la taille d'un int est de 4 octets sur votre machine). En fait, les adresses probablement tous fin dans les chiffres hexadécimaux 0, 4, 8, et C.

Exercice 3: Terminer la conversion des tableaux et Pointer Math, et ce que vous avez commencé dans l'exercice 2, en ayant la deuxième boucle for afficher les valeurs du tableau à l'aide du côté de Peeker de variable pointeur pn.

Exercice 4: Créez un nouveau projet qui remplit un tableau de caractères en utilisant des pointeurs similaires à celles indiquées dans les tableaux et les Pointer Math. Régler la taille du tableau de char à 27 de sorte qu'il peut contenir 26 lettres. Remplissez le tableau avec de 'A' à travers les lettres 'Z' en utilisant la notation de pointeur. Afficher les résultats en utilisant la notation de pointeur.

Voici un indice important:

* PN = x + 'A'-

Solution de l'exercice 4

#include int main () {char alphabet [27] -int x-char * pa-pa = alphabet- / * initialiser pointeur * // * Remplissez tableau * / for (x = 0 XLT; 26-x ++) {* pa = x + 'A'-pa ++ -} pa = alphabet - / * tableau d'affichage * / for (x = 0-XLT; 26-x ++) {putchar (* pa) -pa ++ -} putchar (' n ') - retourner (0) -}

Le code source de Solution de l'exercice 4 devrait être assez lucide, l'exécution de chaque tâche une étape à la fois. Mais gardez à l'esprit que de nombreux programmeurs C aiment combiner déclarations, et ces regroupements se produisent fréquemment avec des pointeurs.

Exercice 5: Combiner les deux états dans la première boucle de la solution à l'exercice 4 être une seule instruction:

* pa ++ = x + 'A'-

Assurez-vous que vous tapez dans correctement. Construire et exécuter.

La sortie est le même. Qu'est-ce que ce désordre laid fait est décrit ici:

x + 'A'This partie de la déclaration est exécuté en premier, en ajoutant la valeur de la variable x à la lettre A. L'effet net est que le code marche jusqu'à l'alphabet que la valeur de x augmente.

* Résultat de Pathé de x + 'A' est placé dans l'emplacement de mémoire spécifié par pointeur pa.

++La valeur de la variable pa - l'adresse de mémoire - est incrémenté d'une unité. Parce que l'++ apparaît après la variable, la valeur est incrémentée après la valeur à cette adresse est lue.

Garder les deux états distincts fonctionne toujours. Mais pas tout programmeur fait ça! Beaucoup d'entre eux aiment à empiler des pointeurs avec l'opérateur d'incrémentation. Méfiez-vous pour cela! Ou, si vous comprenez, l'utiliser.

Exercice 6: Rénovez votre code source à partir de l'exercice 5 sorte que la deuxième boucle for utilise la pa * ++ monstre.

Espérons que la pa * ++ pointeur-chose logique. Si non, faire une sieste et puis revenir et examiner chef-Imploser programme.

HPROGRAMME EAD-implosion

#include int main () {char alpha = 'A'-int x-char * pa-pa = alpha / * initialiser pointeur * / for (x = 0 XLT; 26-x ++) putchar ((* pa) ++) - putchar (' n') - retour (0) -}

Le code source du Listing 19-4 traite avec une variable char unique et non un tableau. Par conséquent, l'initialisation de pointeur à la ligne 9 exige la préfixe. Ne l'oubliez pas!

Ligne 12 dans ce code contient la crotte de nez (* pa) ++. Il ressemble à * pa ++, mais il est certainement pas. Contrairement * pa ++, ce qui jette un œil à une valeur puis incrémente le pointeur, le (* pa) ++ construction incrémente une valeur étant jeté un œil at- le pointeur est inchangé.

Exercice 7: Modifier, construire et exécuter un nouveau programme en utilisant le code source de Head-Imploser programme.

L'opération (* pa) ++ fonctionne, grâce aux parenthèses. Le programme récupère la valeur représentée par * pa d'abord et ensuite cette valeur est incrémentée. La variable de pointeur, pn, ne soit pas affectée par l'opération.

Pour éviter toute confusion sur ce sujet voici les différents éléments du décor de notation cryptique pointeur / de Peeker: