__int64 : macro hi et lo

**mat_monroe** · 16/06/2006, 11h32

Bonjour,

Je dois créer une fonction qui renvoie un couple de int. Pour encapsuler ces 2 int , mon chef de projet m'a dit de les renvoyer sous la forme d'un __int64 afin d'éviter de déclarer une classe dans la DLL que je crée.

Le problème est que j'ai n'ai trouvé nulle part une explication pour les mettre dans ce fichu __int64, ni pour les récuperer après coup.

Il (mon chef de pojet) m'a parlé de macros hi et lo pour récupérer mes deux int mais je n'ai pas trouvé quoi que ce soit là desus non plus.

Bref, je suis paumé avec tout ça...

**Médinoc** · 16/06/2006, 11h34

Pourquoi ne pas utiliser directement un union LARGE_INTEGER ou ULARGE_INTEGER ?

**mat_monroe** · 16/06/2006, 11h38

Tout bêtement parce que je fais ce qu'on me ditde faire, et qu'ils ont besoin que je les mette dans un __int64...

ça ne me réjouit pas plus que ça de le faire de cette façon, mais en gros, il m'a fait comprendre que je n'avais aps el choix...

**nico-pyright(c)** · 16/06/2006, 12h01

tu peux faire un truc du genre (a tester, parce que j'ai pas réfléchi plus que ca aux décalages

)

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
 
__int64 constructI64(int a, int b)
{
	return (__int64)b << 32 | (__int64)a;
}
 
int getLO(__int64 i)
{
	return (int)(i & 0xFFFFFFFF);
}
 
int getHI(__int64 i)
{
	return getLO(i >> 32);
}
 
 
int a = 125;
int b = 952;
__int64 i64 = constructI64(a,b);
 
int a1 = getLO(i64);
int b1 = getHI(i64);

**Médinoc** · 16/06/2006, 13h01

Envoyé par mat_monroe

Tout bêtement parce que je fais ce qu'on me ditde faire, et qu'ils ont besoin que je les mette dans un __int64...

ça ne me réjouit pas plus que ça de le faire de cette façon, mais en gros, il m'a fait comprendre que je n'avais aps el choix...

Euh... Mais le LARGE_INTEGER contient un __int64...

**farscape** · 16/06/2006, 13h42

tu peux utiliser memmove.

Code :

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

1
2
3
4
5
6
7
 
int a = 125;
int b = 952;
__int64 i64 = constructI64(a,b);
Split64( i64,a,b);
ASSERT(a==125);
ASSERT(b==952);

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
__int64 constructI64(int a,int b)
{
   __int64 i64;
   memmove(&i64,&a,sizeof(a));
   memmove(((char *)&i64)+sizeof(b),&b,sizeof(b));
  return i64;
}
void Split64( __int64 i64,int &a,int &b)
{
   memmove(&a,&i64,sizeof(a));
   memmove(&b,((char *)&i64)+sizeof(b),sizeof(b));
}

**Médinoc** · 16/06/2006, 13h53

pourquoi un cast en char* ? memmove prend un void* en paramètre, non?

**farscape** · 16/06/2006, 14h00

oui tu as raison, pour le premier memmove c'est inutile.

**nico-pyright(c)** · 16/06/2006, 14h02

ca vous plait pas les opérations sur les bits ?
avec memove j'aurai l'impression de deployer la grosse artillerie

**farscape** · 16/06/2006, 14h03

Envoyé par nico-pyright(c)

ca vous plait pas les opérations sur les bits ?
avec memove j'aurai l'impression de deployer la grosse artillerie

moi c'est l'inverse lol.

**mat_monroe** · 19/06/2006, 11h01

Merci pour vos réponses...

J'ai été coupé du net pendant le week-end et j'ai donc du trouver une solution tout seul...
J'avais d'abord pensé au décalage de bits avec un masque (comme niconico-pyright(c)) mais j'ai du merdé quelque part parce que ça plantait.

J'ai donc multiplié mon premier nombre par 2^32 puis ajouté le second dans un __int64:

Code :

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

1
2
 
__int64 x=(a*(0x100000000))+b;

Pour récuperer les deux chiffres, je fais:

Code :

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

1
2
3
 
b2=(x%(0x100000000));
a2=((x-b2)/(0x100000000));

C'est pas des plus jolis mais ça marche et ça reste rapide. Je pense que je vais prendre la solution de nico-pyright(c) qui correspondait à ce que j'vais en tête.