Bonjour et bienvenue à nouveau.
Parce que l'arithmétique des points est un concept difficile à comprendre et à
saisir, je voulais passer par un dernier
exemple qui démontre vraiment ce concept, il fait du bon travail.
Et si vous comprenez cet exemple, vous n'aurez
aucun problème avec l'arithmétique des points.
Donc, le premier exemple que je veux vous montrer est
l'effet de l'ajout d'une valeur entière à un pointeur.
Ainsi, lorsque nous faisons de l'arithmétique des pointeurs avec
addition, nous pouvons réellement voir comment cela fonctionne en termes d'adresses.
Donc ici, dans ce programme, tout ce que je fais est de créer une
chaîne, un tableau de caractères, ça s'appelle une chaîne.
Et puis je crée un pointeur de caractère appelé p.
Je passe par toute la longueur de la chaîne qui
est multiple. Je passe donc en revue l'ensemble du tableau.
Nommez simplement basic pour la longueur de force des boucles de taille multiple et multiple.
Et puis j'imprime chaque chaîne
ou caractère réel à l'intérieur de ce tableau.
Et aussi ce que je fais c'est que
j'affiche l'adresse,
puis l'adresse avec le numéro réel que j'ai ajouté.
Regardons donc juste la sortie de ceci parce que la
sortie montre un très bon exemple d'arithmétique de points.
Alors passons aux blocs de code et exécutons ceci.
Nous voici donc dans des blocs de code. J'ai nettoyé un peu le code.
J'utilise la longueur de la chaîne, définit une longueur de la chaîne parce que c'est une inclusion supplémentaire.
Et je veux juste lancer ça.
Donc, quand je lance ceci, ce que vous remarquerez, c'est que cela vous montre
comment vous vous souvenez à quoi ressemble la mémoire, et cela vous montre les
valeurs faisant l'arithmétique des points. Donc, si vous dites plusieurs
sous-0, rappelez-vous, multiple contient juste une chaîne.
Mais si nous regardons ceci et nous disons regarder le contenu du
tableau, les multiples de 0 est a, les multiples de 1 est un espace et le reste est une chaîne.
Voilà le tableau.
Juste à côté, cela revient à ajouter 0 au pointeur et à
le déréférencer, en ajoutant 1 et en ajoutant 2.
Et il vous montre comment faire de l'arithmétique du pointeur en déréférençant
le pointeur lui-même et en lui ajoutant des nombres.
Donc, le pointeur plus sept déréférencement que vous obtenez g.
Ensuite, dans la troisième colonne, je vous montre les adresses réelles au
fur et à mesure que nous incrémentons. Ainsi, les adresses de chaque
élément du tableau en utilisant l'esperluette juste sur le tableau
de caractères, nous voyons l'adresse 060feff pour l'élément 0 et ainsi de suite.
Et puis nous regardons les adresses si nous
ajoutons simplement au pointeur lui-même sans le déréférencer, et
vous verrez les adresses s'aligner.
Et alors nous pouvons regarder la syntaxe pour voir ce qui se passe ici en
termes de la première chose que nous affichons réellement est l'index dans le tableau qui n'est qu'un compteur.
Et puis nous affichons un pourcentage c qui est
le caractère du tableau.
La prochaine chose que nous affichons est
de déréférencer le pointeur plus moi.
Donc, ici, nous affichons I et ensuite nous
affichons la déréférence du pointeur plus I, la
valeur réelle.
Nous
affichons donc comme
d juste le compteur réel, puis le point
c est notre déréférencement. Donc p est notre pointeur.
Nous disons simplement p plus I, arithmétique du pointeur, puis
nous le déréférençons.
Et puis pour obtenir les adresses,
tout ce que nous devons faire pour obtenir l'adresse du
tableau est de dire esperluette multiple, puis l'index.
Pour obtenir la première adresse du pointeur ici, nous disons simplement p
plus I
pour obtenir le compteur réel qui
vous montre comment nous incrémentons ce p, nous
faisons juste un p plus un pourcentage d.
Mais cela montre bien les
différentes façons dont la mémoire vers laquelle nous
pointons les adresses sont
réellement affichées et comment elles sont
équivalentes aux différents index d'un tableau et aux pointeurs réels.
Je pensais que cela faisait du bon travail.
Je veux regarder un autre exemple qui fait un autre bon
travail concernant l'arithmétique des pointeurs avec des longs. Parce qu'ici ce sont
des nombres entiers. Il suffit donc d'en ajouter un et
de passer automatiquement à l'octet suivant et ainsi de suite. Regardons ce que nous faisons, nous faisons longtemps.
Donc, dans cet exemple, je voulais aussi simplement montrer comment vous pouvez faire la
même chose avec un pointeur long et long.
Avec le pointeur de caractère, c'était juste un tableau de caractères de chaîne.
Mais même pour les tableaux longs, qui sont de tailles différentes,
nous pouvons toujours les parcourir à l'aide d'un pointeur
et vous pouvez voir comment le nombre d'octets change réellement.
Donc, même si nous disons que nous avons un pointeur long et que nous en ajoutons un, nous y ajoutons en
fait 4 octets car un long est un peu plus grand et nous le verrons dans cet exemple.
Alors maintenant, exécutons cet exemple dans des blocs de code.
Voici donc notre exemple. Encore une fois, nous avons un compteur entier, un compteur de boucle.
Nous avons une longue gamme de 15l.
Nous spécifions l en mettant le suffixe, puis nous spécifions leurs 1,
leurs longs nous avons un long pointeur qui pointe vers plusieurs.
Encore une fois, comme il s'agit d'un tableau, nous n'avons pas besoin d'utiliser l'adresse de l'opérateur.
Nous allons traverser tout le long. Ici, nous ne pouvons pas utiliser la longueur d'agitation dont
nous devons utiliser la taille, et nous devons en fait la diviser par chaque point du tableau.
Donc, la taille totale divisée par le point unique dans le tableau, c'est
à ce moment-là que nous voulons sauter parce
que ceux-ci se souviennent de nos adresses qui sont incrémentées de 4 octets chacune.
Et encore une fois, ce que nous faisons ici, c'est que nous
affichons simplement le pointeur par rapport au tableau et vous montrons
comment ils sont liés, puis nous affichons le nombre total
total d'octets que le long est sur notre système.
Et donc, cela montre encore une fois comment les tableaux
sont liés aux pointeurs.
Donc, si nous exécutons
ceci, nous allons voir une sortie similaire. Mais ce qui est un peu différent ici,
c'est la taille de l'adresse, qui augmente de 4 octets. Nous allons donc imprimer l'adresse et le pointeur.
Donc, pour l'adresse et le pointeur plus
0, cela va être égal
au sous-tableau 0 qui est l'adresse 6356728.
Et pour déréférencer le pointeur, nous obtiendrons la valeur 15.
Ainsi, p plus 0 sera toujours égal au sous-tableau 0.
Et là encore, nous faisons la même chose pour p plus un p plus
2 et p plus 3, tous équivalents aux points corrects dans le tableau pour l'index.
Les adresses augmentent de 4 octets, mais on peut quand même ajouter juste un 2 et un 3 et
on voit que les valeurs sont les mêmes.
Et puis il nous dit que ce long occupe 4 octets et c'est pourquoi les adresses augmentent de 4.
Ce qui est important ici, c'est que nous pouvons toujours en ajouter
un et que le compilateur sait aller à l'adresse suivante.
Donc, que nous ayons un long ou un caractère ou quel
que soit ce type de données particulier à l'intérieur du système,
l'ajout d'un ou deux ajoutera le nombre correct d'octets.
Donc, juste un autre exemple sympa que je
voulais vous montrer car cette arithmétique de pointeur est vraiment importante et elle
est vraiment utile lors de l'itération ou
de la traversée d'un tableau, elle rend beaucoup plus propre et beaucoup plus efficace.
J'espère donc que cela a aidé. Merci.