Bjr,

En faisant de la revue de code je suis tombé sur une situation équivalente à ce qui suit:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int _tmain(int argc, _TCHAR* argv[])
{
    unsigned int* pInt;
    unsigned int K=1;
 
    unsigned char* pChar;
    unsigned char C='a';
 
    pInt= &K;
    printf( "pInt : %i\n", *pInt);
    *pInt+= 1;
    printf( "pInt : %i\n", *pInt);
    (*pInt)++;
    printf( "pInt : %i\n", *pInt);
 
    pChar= &C;
    printf( "pChar : %c\n", *pChar);
    *pChar+= 1;
    printf( "pChar : %c\n", *pChar);
    (*pChar)++;
    printf( "pChar : %c\n", *pChar);
    return 0;
}
On obtient la sortie console suivante :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
pInt : 1
pInt : 2
pInt : 3
pChar : a
pChar : b
pChar : c
Si l'on se focalise sur les incréments de valeurs pointées on obtient le code asm suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
	*pInt+= 1;
004113EC  mov         eax,dword ptr [pInt] 
004113EF  mov         ecx,dword ptr [eax] 
004113F1  add         ecx,1 
004113F4  mov         edx,dword ptr [pInt] 
004113F7  mov         dword ptr [edx],ecx 
	(*pInt)++;
00411416  mov         eax,dword ptr [pInt] 
00411419  mov         ecx,dword ptr [eax] 
0041141B  add         ecx,1 
0041141E  mov         edx,dword ptr [pInt] 
00411421  mov         dword ptr [edx],ecx 
 
	*pChar+= 1;
00411464  mov         eax,dword ptr [pChar] 
00411467  movzx       ecx,byte ptr [eax] 
0041146A  add         ecx,1 
0041146D  mov         edx,dword ptr [pChar] 
00411470  mov         byte ptr [edx],cl 
	(*pChar)++;
00411490  mov         eax,dword ptr [pChar] 
00411493  mov         cl,byte ptr [eax] 
00411495  add         cl,1 
00411498  mov         edx,dword ptr [pChar] 
0041149B  mov         byte ptr [edx],cl
Alors que les deux premiers incréments sur unsigned int* mènent à un code machine identique, leurs transpositions syntaxiques sur des unsigned char* mènent à deux séquences de code machine différentes.

Deux questions en découlent :
Ces dernières deux instructions sont elles vraiment équivalentes :
Fonctionnellement parlant?
En efficacité ? c.à.d. même nombre de cycle CPU ? 'je présume que oui, mais je ne suis pas un spécialiste de l'architecture Intel x86.