Pour ma classe, je dois démontrer la manipulation d'un tableau avec des pointeurs. La première partie consistait à produire une valeur à l'aide de pointeurs, ce que j'ai déjà fait. La deuxième partie est celle avec laquelle j'ai besoin d'aide. Avec le code donné, je dois sortir ar [0] [3] en utilisant le pointeur p. Je ne demande pas de réponse, je veux juste savoir comment cela doit être fait. De plus, je ne sais pas pourquoi le pointeur p et q s'initialisent tous les deux à l'adresse 9 lorsque je démarre le programme. Ce n'est qu'une question secondaire. Voici le code donné.

int ar[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12};
int **p;

int *q;

p=&q;

q =*(ar+2);

Écrivez en utilisant l'arithmétique du pointeur comment changerait la valeur de ar [0] [3] en utilisant le pointeur p.

Je vais également envoyer un courriel à mon professeur pour lui demander, mais il est peu probable qu'il réponde aujourd'hui, c'est pourquoi je vous pose la question. Merci d'avance.

0
killerkody gaming 6 avril 2020 à 01:54

3 réponses

Meilleure réponse

comment changerait la valeur de ar [0] [3] en utilisant le pointeur p.

Tout d'abord, affectez q à pointer vers ar[0][3]. Il n'est pas clair si l'exigence arbitraire d'utiliser p s'applique à cela, mais supposons que q doit être modifié en indirectant via p:

*p = &ar[0][3];

Indiquez ensuite indirectement via q pour accéder à l'élément et modifiez la valeur en lui affectant:

**p = new_value;

y a-t-il une raison pour laquelle je ne peux pas simplement utiliser *p = new_value?

p est un pointeur vers un pointeur vers un entier. Lorsque vous indirecte via p, vous obtenez le pointeur sur un entier qui est pointé vers. Vous ne pouvez pas affecter une valeur entière à un "pointeur vers un entier". Vous devez indirectement via le "pointeur vers un entier" pour avoir accès à un entier pointé. Donc, d'abord indirectement via le pointeur vers le pointeur vers l'entier afin d'obtenir le pointeur vers l'entier, puis indirect via le pointeur vers l'entier afin d'obtenir l'entier, dont vous pouvez attribuer la valeur. C'est à dire. **p = new_value;

ou [*p = new_value] remplacera-t-il simplement *p?

Oui. L'affectation à un objet écrase la valeur de l'objet. Dans ce cas, l'objet affecté est le pointeur q.

1
eerorika 6 avril 2020 à 00:38

Vous avez donc compris comment manipuler un tableau unidimensionnel avec des pointeurs. C'est facile car un tableau peut être simplement traité comme un pointeur et le nombre entre crochets n'est qu'un moyen d'incrémenter le pointeur arr [i] est équivalent à * (arr + i). Une approche similaire peut être faite pour un tableau à 2 dimensions, pour un tableau arr [i] [j], nous dé-référençons d'abord arr + i pour obtenir un nouveau tableau contenant les j membres, puis nous dé-référençons * (arr + i) + j pour obtenir enfin ( (arr + i) + j), le code devrait ressembler à ceci:

#include <iostream>
using namespace std;
int main()
{
    int arr[3][3] = {1,2,3,
                     4,5,6,
                     7,8,9};
    int i=1,j=2;
    cout << *(*(arr+i)+j);
}

Donc, un autre exemple, si nous avons un tableau tridimensionnel, arr [a] [b] [c], pour extraire un élément à l'aide de pointeurs, nous pouvons le faire comme ceci:

*(*(*(arr+a)+b)+c)
0
aliberro 5 avril 2020 à 23:51

Je trouve qu'il est plus facile de raisonner sur les tableaux si vous n'essayez pas de penser à un tableau 2D comme quelque chose de spécial. Ça ne l'est pas. C'est juste un tableau de tableaux.

int **p n'est pas le bon type à utiliser. Un tableau de tableaux de int ne peut pas être converti en un pointeur en un pointeur vers un int.

Un tableau peut se désintégrer en un pointeur sur son premier élément. Alors, quel est le type du premier élément d'un tableau de 3 tableaux de 4 int s? C'est un tableau de 4 int. Cela signifie que le type dans lequel un int[3][4] va se désintégrer n'est pas int**, c'est int (*)[4]: un pointeur vers un tableau de 4 int s.

int ar[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
// ar decays to a pointer to its first element, which is an array of 4 ints,
// so p is a pointer to an array of 4 ints, pointing to the first element of ar
int (*p)[4] = ar;
// You can then dereference p, yielding an array of 4 ints.
// That array decays to a pointer to its first element, which is an int,
// so q is a pointer to an int, pointing to the first element of the first element
// of ar
int *q = *p;
// To get the 3rd element of the first element of ar, shift q 2 positions and then
// dereference the resulting pointer
std::cout << *(q + 2);  // output the desired element

Démo en direct


Bien sûr, vous n'avez pas besoin des variables intermédiaires p et q. Vous pouvez tout faire en une seule ligne:

int ar[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
// 1. ar decays to a pointer to its first element
// 2. Dereference the pointer that ar decayed into
// 3. The array yielded by the dereference in (2) decays into a pointer to
//    its first element
// 4. Offset the pointer that results from (3) by two positions
// 5. Dereference the pointer from (4) to access the third element of the
//    first element of ar
std::cout << *(*ar + 2);

Démo en direct

Il s'agit d'une seule ligne assez complexe, donc les variables intermédiaires supplémentaires peuvent aider à rendre plus clair ce qui se passe.

0
Miles Budnek 5 avril 2020 à 23:43