Comportement de l'opérateur ++ dans un pointeur

Question

J'ai un tableau de structures, et j'ai créé un pointeur sur le premier élément de la structure. J'ai vu la fonction ++ utilisé dans mon code sur le pointeur, comme ceci : ptrStruct++ Quel est le rôle exact de ce système ? Passer à la position suivante du tableau ? Ou bien il est utilisé comme opérateur de surcharge ?

Code ici, et les objets proviennent d'Ogre3D :

RGBA colours[nVertices];
RGBA *pColour = colours;
rs->convertColourValue(ColourValue(1.0,0.0,0.0), pColour++); //0 colour
rs->convertColourValue(ColourValue(1.0,1.0,0.0), pColour++); //1 colour
rs->convertColourValue(ColourValue(0.0,1.0,0.0), pColour++); //2 colour

Answer 1

++ lorsqu'elle est appliquée à un pointeur, fait passer ledit pointeur à l'étape suivante. article. Pour ce faire, il s'adapte à la taille de l'élément pointé.

Ainsi, si vous avez un char *pc pointer vers l'emplacement 0x1000 , pc++ le fera passer à l'étape suivante char ou 0x1001 . Toutefois, un int *pi (en supposant que sizeof (int) es 4 ) avancerait de l'emplacement 0x1000 a 0x1004 .

Ce n'est pas quelque chose dont vous devez normalement vous préoccuper, à moins que vous ne fassiez un casting entre différents pointeurs. Il suffit de dire que :

RGBA colours[nVertices];
RGBA *pColour = colours;    // same as &(colours[0])
pColour++;                  //     now &(colours[1])

avancera simplement pColour pour pointer vers colours[1] .

Answer 2

ptrStruct++

Le pointeur avance et pointe sur l'élément suivant du tableau. Le compilateur connaît la taille de chaque élément du tableau. ++ avance le pointeur dans la mémoire en fonction de cette taille.

RGBA colours[nVertices];  // Assume `sizeof(RGBA)` is 4bytes
RGBA *pColour = colours;

      sizeof(a[0])                                 
     <------------>                                
     +------------+------------+-------------+--------
     |            |            |             |     
     |   4bytes   |   4bytes   |   4bytes    |  4by...   
     |            |            |             |     
     +------------+------------+-------------+--------
     ^            ^                                
     |            |                                
   before       after++ 
   pColour      pColour 

En tant que pointeur vers un RGBA avec taille 4, chacun ++ dit au compilateur d'avancer de 4 octets. En d'autres termes, la longueur d'un seul pas est de 4 octets.

Vous pouvez également réécrire le code comme suit :

RGBA colours[nVertices];
int i = 0;
rs->convertColourValue(ColourValue(1.0,0.0,0.0), colours[i++]);
rs->convertColourValue(ColourValue(1.0,1.0,0.0), colours[i++]);
rs->convertColourValue(ColourValue(0.0,1.0,0.0), colours[i++]);

Answer 3

Il s'incrémente jusqu'à la prochaine adresse mémoire contenue dans le tableau. En pratique, address + sizeof(array[0]). Cela fonctionnera pour n'importe quel type (complet).

Answer 4

Vous avez déclaré le pointeur comme

RGBA *pColour = colours;

Ainsi, pclour++ signifie pcolour + sizeof(RGBA)

Answer 5

Il passe à l'élément suivant de la liste. Je laisserais bien ce commentaire, mais je ne peux pas encore le faire.