Discussion :

[lpierard]

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.

[LittleWhite]

Bonjour,

Je pense qu'ils auront la même vitesse ... car sur les processeur 32bits ... la variable et pointeur sur 32 bits et généré d'un cycle ( sur processeur 64 bits aussi )
Les 8 bits sont aussi géré d'un trait
Après ... pour l'histoire de différence ... il faut savoir juste qu'un char ne pourra pas dépasser 255 ... rien d'autre

[jeroman]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*pChar+= 1;

Je vais peut-être dire une bêtise, mais peut-être est-ce parce que '1' est ici considéré comme un 'int' et qu'il faut alors d'abord convertir l'objet 'char' en 'int' avant de traiter.
Je ne sais plus ce que dit la norme au sujet d'opérations entre objets de types (char,int, etc) différents.

[LittleWhite]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*pChar+= 1;

Je vais peut-être dire une bêtise, mais peut-être est-ce parce que '1' est ici considéré comme un 'int' et qu'il faut alors d'abord convertir l'objet 'char' en 'int' avant de traiter.
Je ne sais plus ce que dit la norme au sujet d'opérations entre objets de types (char,int, etc) différents.

Je ne vois pas ce que cela va changer. Dans le code assembleur, l'addition du '1' est écrite en dur ( et c'est normal ).
Après, peut être il y aura un gain en mémoire avec le cast ... ou même plus intelligement avec un suffixe ( 1f ... sauf que là ce n'est pas le 'f' qu'il faut ... je ne sais pas si cela existe ).

[lpierard]

En fait j'ai trouvé le tableau suivant chez Intel :



Le premier incrément en code machine est donc effectué sur 32bits.
Le second sur 8 bits.

Curieusement le premier incrément est également effectué sur 32 bits lorsque l'on cast le 1 en unsigned char. C'est à dire que le code machine ne change pas.

Dans les deux cas c'est les 8 bits les + bas qui sont remontés en mémoire.

Je n'ai pas d'info officielle sur le nbre de cycle horloge des instructions concernées, mais je presque sûr qu'elle sont identiques.

Le travail du compilateur me semble + fidèle à ma pensée dans le deuxième cas. Même si le résultat est strictement identique dans les deux cas.

Merci de votre attention, et de votre patience.
A+

[diogene]

Curieusement le premier incrément est également effectué sur 32 bits lorsque l'on cast le 1 en unsigned char.

Caster le 1 en unsigned char ne sert à rien :
Une expression telle que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 a += b   //(a et b entiers)

équivaut à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 a = a+b

sauf que a ne sera évalué qu'une fois.

L'évaluation de cette expression commence par la promotion des "petits entiers" : la valeur des opérandes de rang inférieur à int sera convertie automatiquement en int (ou en unsigned int si la promotion en int ne permet pas de conserver la valeur).