Que se passe-t-il lorsque l'arithmétique des pointeurs est utilisée comme argument d'une fonction en c++ ?

Question

Je suis un cours d'introduction au c++ où nous apprenons à mettre en œuvre le mergesort. J'essaie de me guider à travers chaque étape du code, mais il y a un élément qui me fait trébucher :

1. void mergeSort(int *x, int len){
2. if (len>1){
3. int newLen=len/2;
4. mergeSort(x, newLen);
5. mergeSort(x+newLen,len-newLen);
6. int *newSeq;
7. newSeq=new int[len];
8. mTwoSeq(x, x+newLen, newSeq,newLen, len-newLen);
9.  for(int i=0;i<len;++i){
10.   x[i]=newSeq[i];
11.     }
12. delete[] newSeq;
13.   }
14. }

Que se passe-t-il à la ligne 5 ? Si j'ai bien compris, lorsque nous appelons "x+i", où x est un tableau de pointeurs, nous demandons à l'ordinateur de nous donner l'adresse du morceau de mémoire qui contient le ième élément de données. Si c'est le cas, je ne suis pas tout à fait sûr de savoir comment cela s'intègre ici. Si quelqu'un sait ce qui se passe dans cet appel de fonction, je serais très heureux de le savoir. Merci !

Answer 1

Les lignes 4 et 5 traitent le tableau comme deux "moitiés" qui seront ensuite chacune triées par un appel récursif. Le premier argument de l'appel de la ligne 5 ( x + newLen ) calcule l'adresse de l'élément qui se trouve (approximativement) au milieu du tableau puisque newLen est (environ) la moitié de la longueur. (Je dis "approximativement" et "environ" ici parce que cela dépend si la valeur originale de len est impair ou pair).

Vous avez raison de dire que x + newLen utilise une "arithmétique de pointeur", puisque x est un pointeur. En supposant, comme c'est le cas sur beaucoup/la plupart des systèmes, que la taille d'un int sur votre système est de 4 octets, alors à titre d'exemple, si newLen est de 12, le pointeur qui résulte de l'exécution de la commande x + newLen sera en fait une adresse en mémoire qui est 48 supérieure à la valeur initiale de x (car l'arithmétique des pointeurs prend en compte la taille du type d'élément pointé). Cela signifie que x + newLen pointe vers un nombre entier à 12 points du début du tableau.

Enfin, le commentateur ci-dessus a eu raison de vous corriger. x n'est pas un tableau de pointeurs. Il s'agit plutôt d'un pointeur vers un entier, qui se trouve vraisemblablement au premier endroit du tableau (ou sous tableau) d'entiers à trier.

Answer 2

Une chose inhabituelle en C++ (et C) est que lorsque vous déclarez un tableau, comme ceci :

int a[5] ;

Le nom 'a' est en fait équivalent à &(a[0]), l'adresse du premier élément du tableau. En d'autres termes, lorsque vous utilisez 'a' dans une expression, il s'agit d'une valeur de pointeur, et non d'une valeur de variable. Vous pouvez donc utiliser arithmétique des pointeurs sur elle. Ainsi, a + 1 sera équivalent à &(a[1]). C'est pourquoi une déclaration comme celle-ci :

int *p = a, *p2 = a + 1 ;

est autorisé. Puisque les pointeurs peuvent pointer à la fois vers des variables et des éléments de tableau, si vous écrivez p[1], le compilateur supposera que p pointe vers un tableau, ce qui dans cet exemple est correct, donc p[1] est le même élément de tableau que a[1]. *(p2 - 1) et p2[-1] font tous deux référence au même élément de tableau que a[0] dans cet exemple.