Changer le pointeur sur un tableau pour obtenir un élément de tableau spécifique

Question

Je comprends la signification générale des pointeurs et des références (ou du moins, je pense que je le comprends), mais je comprends aussi que, lorsque j'utilise new , j'alloue de la mémoire de manière dynamique.

Ma question est la suivante:

Si je devais utiliser cout << &p, le & "; emplacement de la mémoire virtuelle &"; de p. Existe-t-il un moyen de manipuler cet & "Emplacement de mémoire virtuelle? &";

Par exemple, le code suivant montre un tableau de int s.

Si je voulais afficher la valeur de p[1] et que je connaissais le " emplacement de la mémoire virtuelle " de &p + 1, pourrais-je faire en quelque sorte & "; cout << *p &"; et obtenez la valeur de <=> avec <=>, qui pointe maintenant sur le deuxième élément du tableau?

int *p;
p = new int[3];

p[0] = 13;
p[1] = 54;
p[2] = 42;

Answer 1

Bien sûr, vous pouvez manipuler le pointeur pour accéder aux différents éléments du tableau, mais vous devrez manipuler le contenu du pointeur (c'est-à-dire l'adresse de ce que p pointe sur), plutôt que l'adresse du pointeur lui-même. .

int *p = new int[3];
p[0] = 13;
p[1] = 54;
p[2] = 42;

cout << *p << ' ' << *(p+1) << ' ' << *(p+2);

Chaque addition (ou soustraction) signifie l’élément ultérieur (précédent) du tableau. Si p pointe sur une variable de 4 octets (par exemple, int sur un PC 32 bits typique) à l’adresse, par exemple 12345, p + 1 désignera 12349 et non 12346. Notez que vous souhaitez modifier la valeur de que contient p avant de le déréférencer pour accéder à ce qu’il pointe.

Answer 2

Pas tout à fait. &p est l'adresse du pointeur p . &p+1 fera référence à une adresse qui est une int* plus loin. Ce que vous voulez faire est

p=p+1; /* or ++p or p++ */

Maintenant, quand vous faites

cout << *p;

Vous obtiendrez 54. La différence est que <=> contient l'adresse du début du tableau d'ints , tandis que <=> est l'adresse de p . . Pour déplacer un élément, vous devez pointer plus loin dans le int array , et non plus loin dans votre pile, là où <=> réside.

Si vous n'aviez que <=>, vous devrez alors procéder comme suit:

int **q = &p; /* q now points to p */
*q = *q+1;
cout << *p;

Cela produira également 54 si je ne me trompe pas.

Answer 3

Cela fait un certain temps (plusieurs années) que je travaille avec les pointeurs, mais je sais que si p pointe vers le début du tableau (c.-à-d. p [0]) et que vous l'incrémentez (c.-à-d. p ++), alors p sera maintenant en pointant sur p [1].

Je pense que vous devez dé-référencer p pour obtenir la valeur. Vous déréférencez un pointeur en plaçant un * devant celui-ci.

So * p = 33 avec modification de p [0] à 33.

Je suppose que pour obtenir le deuxième élément, vous utiliseriez * (p + 1), de sorte que la syntaxe dont vous auriez besoin serait la suivante:

cout << *(p+1)

ou

cout << *(++p)

Answer 4

J'aime faire ceci:

&p[1]

Pour moi, cela a l'air plus net.

Answer 5

Pensez à " types de pointeur " C et C ++ définissent une très longue rangée de cellules logique superposée aux octets de l’espace mémoire de la CPU, à partir de l’octet 0. La largeur de chaque cellule, en octets, dépend le " type " du pointeur. Chaque type de pointeur établit une ligne avec des largeurs de cellules différentes. Un pointeur "int *" définit une rangée de cellules de 4 octets, car la largeur de stockage d'un entier est de 4 octets. Un "double *" définit une ligne de 8 octets par cellule; un pointeur "struct foo *" définit une ligne avec chaque cellule la largeur d'un seul "struct foo", quel qu'il soit. L’adresse & Quot; adresse & Quot; de toute " chose " est le décalage d'octet, commençant à 0, de la cellule de la ligne contenant le & "objet &";

L'arithmétique du pointeur est basée sur les cellules de la ligne et non sur les octets. . & "; *(p+10) &"; est une référence à la 10ème cellule après " p " ;, où la taille de la cellule est déterminée par le type de p. Si le type de & Quot; p & Quot; est " int " ;, l'adresse de " p + 10 " est passé de 40 octets p; si p est un pointeur sur une structure de 1000 octets de long, " p + 10 " est de 10 000 octets passés p. (Notez que le compilateur doit choisir une taille optimale pour une structure qui peut être plus grande que ce que l'on pourrait penser; ceci est dû à & "; Padding &" Et à & "Alignement & La structure de 1000 octets discutée peut en fait prendre 1024 octets par cellule, par exemple, donc & "p + 10 &" sera en réalité de 10 240 octets après p.)