Dépassement capacité multiplication integerRésolu

Question

Bonjour,



J'ai trois integer 64 bits :

_int64 i1,i2,i3;



Comment d&#233;tecter le d&#233;passement de capacit&#233; possible sur i3, lors d'une multiplication :

i3 = i1 * i2;



Merci.

bipcpp · Accepted Answer

J'ai trouv&#233; ceci par hazard dans le MSDN:



-----------------------------------

_int64 i1,i2,i3;

 

if (i1 > (MAX / i2) )

   cout << "D&#233;passement";

else

    i3 = i1 * i2;



---------------------------

MAX doit contenir la valeur maximale de _int64



Et &#231;a &#224; l'air de fonctionner.



Merci pour toutes vos r&#233;ponses.

cosmobob · Answer

salut,

si ca d&#233;borde, i3 aura la particularit&#233; d'etre inferieur &#224; i1 ou &#224; i2.



a+

Galmiza · Answer

Pourtant, en assembleur, il y a des flags qui changent d'&#233;tats pour ce genre de chose.

Quand tu fais une op&#233;ration et que le resultat vaut 0, est n&#233;gatif ou
depasse la memoire, des bits du flag prennent des valeurs sp&#233;cifiques.

Mais comment lire ces flags, je ne sais pas.

Ils sont surtout utiles pour les optimisations de code.

BruNews · Answer

Lire CF ici n'aurait pas de sens.
La mul sur 64 bits implique au mieux 1 mul SINON 3 mul et 2 add
Le flag sera positionn&#233; par le dernier add et donc ne voudrait rien dire.

ciao...
BruNews, MVP VC++

vecchio56 · Answer

Même en cas de débordement, on ne peut pas être sûr que i3 sera inférieur à i2 et i1 (par contre le contraire est sûr), a mon avis ca dépend de la manière dont le compilo implémente la multiplication sur 64 bits

BruNews · Answer

cosmobob a bien dit inf &#224; l'un OU l'autre.

ciao...
BruNews, MVP VC++

vecchio56 · Answer

et pourquoi il serait pas supérieur au 2?

BruNews · Answer

Voila pour vecchio.
Galmiza > pas &#233;vident de dire quand overflow, sinon faut d&#233;finir la r&#232;gle du jeu.

    mov       eax, [esp+8]        ; HIDWORD(x)
    mov       ecx, [esp+16]       ; HIDWORD(y)
    or        ecx, eax
    mov       ecx, [esp+12]       ; LODWORD(y)
    jnz       short hard
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       ecx
    jmp       short mulExit
hard:
    mul       ecx
    mov       [esp-4], eax        ; SAUVE RESULTAT INTERMEDIAIRE
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       dword ptr[esp+16]   ; HIDWORD(y)
    add       [esp-4], eax
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       ecx
    add       edx, [esp-4]
mulExit:
    ret       16

ciao...
BruNews, MVP VC++

BruNews · Answer

vecchio, tu aurais un exemple de inf&#233;rieur aux 2 ?

ciao...
BruNews, MVP VC++

vecchio56 · Answer

#include 

int main()
{
  unsigned __int64 a 0xFFFFFFFFF, b 0xFFFFFFFFF;
  unsigned __int64 r = a * b;
  if(r < a || r < b) std::cout << "débordement" << std::endl;
}

Cet exemple ne m'affiche pas "débordement"

vecchio56 · Answer

Le resultat est faux, mais est supérieur aux 2 opérandes, c'est bien ce que je cherchais, BruNews (pas inférieur comme tu as dit)

BruNews · Answer

mais pas de d&#233;bordement ici, enfin ne me semble pas.

ciao...
BruNews, MVP VC++

vecchio56 · Answer

a et b sont sur 36 bits chacuns, ca devait donner environ 2^72... par contre j'ai triché parce qu'il fallait pas utiliser des unsigned

BruNews · Answer

ah si ah si, OUPS.

ciao...
BruNews, MVP VC++

BruNews · Answer

ok trop tard de 10 secondes...

ciao...
BruNews, MVP VC++

cosmobob · Answer

salut, moi j'ai pas d'overflow dans l'exemple de vecchio, et le résultat affiché est correct (vérifié avec la calculette de windows) #include #include int main(int argc, char* argv[]) { unsigned __int64 a = 0xFFFFFFFF; unsigned __int64 b = 0xFFFFFFFF; unsigned __int64 r = a*b; char buffer[100]; _ui64toa(r, buffer, 10); printf("%s ", buffer); return 0; }

cosmobob · Answer

ha j'ai oubli&#233; un F non ? :p

effectivement ca foire

vecchio56 · Answer

La calculette de Windows marche pas bien, pas plus de 64 bits en mode hexa, donc ca donne le même résultat que VC++, mais les deux sont faux:
Tu mets 4722366482732206260225 en décimal, tu mets en hexa puis reviens en décimal, et le on obtient 18446743936270598145 :)

gotjehiuh · Answer

Pour savoir si &#231;a d&#233;passe ou non, tu peux convertir i1 et i2 en double et faire un test dessus. 


Non ?

BruNews · Answer

Bon voila je vous soumets cela, &#231;a a l'air coh&#233;rent, faudrait faire des tests:

__declspec(naked) __int64 __stdcall mymul64(__int64 x, __int64 y, int *overflow)
{
  __asm {
    mov       eax, [esp+8]        ; HIDWORD(x)
    mov       ecx, [esp+16]       ; HIDWORD(y)
    mov       edx, [esp+20]       ; *overflow
    or        ecx, eax
    mov       ecx, [esp+12]       ; LODWORD(y)
    mov       dword ptr[edx], 0   ; overflow = 0
    jnz       short hard
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       ecx
    jmp       short mulExit
 hard:
    mov       [esp-8], ebx
    mul       ecx
    mov       [esp-4], eax        ; SAUVE RESULTAT INTERMEDIAIRE
    xor       ebx, ebx
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       dword ptr[esp+16]   ; HIDWORD(y)
    add       [esp-4], eax
    adc       ebx, 0
    mov       eax, [esp+4]        ; LODWORD(x)
    mul       ecx
    add       edx, [esp-4]
    mov       ecx, [esp+20]       ; *overflow
    adc       ebx, 0
    mov       [ecx], ebx
    mov       ebx, [esp-8]
mulExit:
    ret     20
  }
}


int WINAPI WinMain(HINSTANCE h, HINSTANCE x, LPSTR ystr, int z)
{
  char buf[24];
  __int64 a, b;
  int deborde;
  a = 0xFFFFFFFFFFFFFFF;
  b = 0xFFFFFFFFF;
  a = mymul64(a, b, &deborde);
  _i64toa(a, buf, 10);
  MessageBox(0, buf, "R", 0);
  
  if(deborde) MessageBox(0, "overflow", "R", 0);
  
  return 0;
}

ciao...
BruNews, MVP VC++

Dépassement capacité multiplication integer

31 réponses

Votre réponse

Discussions similaires