__int64 : macro hi et lo

Version imprimable

16/06/2006, 11h32
mat_monroe

__int64 : macro hi et lo

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...
16/06/2006, 11h34
Médinoc

Pourquoi ne pas utiliser directement un union LARGE_INTEGER ou ULARGE_INTEGER ?
16/06/2006, 11h38
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...

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

Code:

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);

16/06/2006, 13h01
Médinoc

Citation:

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...

tu peux utiliser memmove.

Code:

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:

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));
}

16/06/2006, 13h53
Médinoc

pourquoi un cast en char* ? memmove prend un void* en paramètre, non?
16/06/2006, 14h00
farscape

oui tu as raison, pour le premier memmove c'est inutile.
:D
16/06/2006, 14h02
nico-pyright(c)

ca vous plait pas les opérations sur les bits ?
avec memove j'aurai l'impression de deployer la grosse artillerie :P
16/06/2006, 14h03
farscape

Citation:

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 :P

moi c'est l'inverse lol.:D
19/06/2006, 11h01
mat_monroe
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:

1 2 __int64 x=(a*(0x100000000))+b;
Pour récuperer les deux chiffres, je fais:
Code:

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.
19/06/2006, 11h09
nico-pyright(c)

Citation:

Envoyé par mat_monroe

Je pense que je vais prendre la solution de nico-pyright(c) qui correspondait à ce que j'vais en tête.

gnarf gnarf :mrgreen:

vérifie quand meme que ca marche bien pour les nombres à la limite de la capacité d'un entier ;)
20/06/2006, 11h25
mat_monroe

ça devrait aller... mes deux nombres sont les coordonées d'un point sur une image 400 x 256 pixels...