Bonjour,
pour m'exercer j'essaie de cr�er une classe u64 (unsigned cod�s sur 64 bits), en surchargeant les op�rations sur cette classe:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
struct u64
{
     u32 faible;
     u32 fort;
 
     u64(u64 &right) {
          faible = right.faible;
          fort = right.fort;
     }
 
     // u32 -> u64
     u64(u32 right) {
          faible = right;
          fort = 0;
     }
 
     u64& operator=(const u64 &right) {
          faible = right.faible;
          fort = right.fort;
          return (*this);
     }
 
     inline static void multiplie(const u32 left, const u32 right, u64 &result) {
          u32 a,b,c,d,i,j,k,l;
          a = left & 0xffff;
          b = ((u32)left) >> 16;
          c = right & 0xffff;
          d = ((u32)right) >> 16;
 
          i = a * c;
          j = a * d;
          k = b * c;
          l = b * d;
          j += k;
          if(j < k)
               l++;
 
          result.faible = i + (j << 16);	// pas d'overFlow possible
          result.fort = l + (((u32)j) >> 16);	// idem
     }
 
     // u64 -> u32
     operator unsigned int const (void) {
          return faible;
     }
 
};
 
u64 operator*(const u64 &left, const u64 &right) {
     u64 result;
     u64 i,j,k;
 
     u64::multiplie(left.faible,right.faible,result);
     if((left.fort) || (right.faible)) {
          u64::multiplie(left.fort,right.faible,j);
          u64::multiplie(left.faible,right.fort,k);
          result.fort += j.faible + k.faible;
     }
 
     return result;
}
mais si j'execute le code suivant:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
u64 a = 1 << 31;
u64 b = 1 << 31;
u64 c = a * b;
c vaut 0 !

alors que ceci:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
u64 a = 1 << 31;
u64 b = 1 << 31;
u64 c;
c = a * b;
me renvoie bien le bon r�sultat 1 << 62.

en step-by-step, on voit que dans le premier cas c'est l'op�rateur de copie qui est utilis�, et pour une raison qui m'�chappe, dans le second cas le compilo pr�f�re caster le r�sultat de a * b en u32 puis lui appliquer le constructeur 32 bits u64(u32 right) plut�t que d'utiliser directement l'op�rateur de copie 64 bits u64(u64 &right).
A noter que si j'enl�ve le code permettant le cast de u64 � u32, ou le constructeur 32 bits u64(u32 right), alors il utilise bien l'op�rateur de copie 64 bits u64(u64 &right) et la valeur de c devient juste dans les 2 morceaux de codes ci-dessus.

D'o� ma question: 1) commet expliquer au compilo que c'est bien l'op�rateur de copie 64 bit qu'il doit utiliser dans ce cas, et pas le constructeur 32 bits ?

et 2) (question subsidiaire): est-ce que c'est possible de d�sactiver le cast implicite dans le code:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
operator unsigned int const (void) {
     return faible;
}
un peu dans le genre du mot cl� explicit qu'on peut ajouter devant:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
explicit u64(u32 right) {
     faible = right;
     fort = 0;
}
puisque en principe on voudrait plut�t que l'utilisateur puisse faire librement des:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
u64 a;
u32 b = 10;
a = b;
plut�t que des:

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
u64 a = 1 << 50;
u32 b;
b = a;
(qui eux devraient g�n�rer une erreur sauf si on cast b = (u32)a; )

merci d'avance !