entiers 64 bits et operateurs sur les bits

bonjour,

je voudrais pouvoir utiliser les operateurs sur les bits : <<,|,&, sur des entiers de 64 bits (jeu d'echec) pour faire des masques...

bref, tous ces operateurs ne fonctionnent pas au-dessus de 32 bits, ci-dessous un code d'exemple : 1<<34 est affiché comme 0.

Comment s'en sortir, si-possible de maniere la plus portable possible (linux...)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <stdio.h> #include <stdlib.h> #include <stdint.h>   int main(int argc, char *argv[]) { unsigned __int64 n=0; n|=(1<<34); printf("%I64x\n",n); system("PAUSE"); return 0; }

---

Hi,

Citation:

---

Envoyé par xantares

bonjour,

je voudrais pouvoir utiliser les operateurs sur les bits : <<,|,&, sur des entiers de 64 bits (jeu d'echec) pour faire des masques...

bref, tous ces operateurs ne fonctionnent pas au-dessus de 32 bits, ci-dessous un code d'exemple : 1<<34 est affiché comme 0.

Comment s'en sortir, si-possible de maniere la plus portable possible (linux...)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <stdio.h> #include <stdlib.h> #include <stdint.h>   int main(int argc, char *argv[]) { unsigned __int64 n=0; n|=(1<<34); printf("%I64x\n",n); system("PAUSE"); return 0; }

---

---

Je pense que dans la ligne

Code:

---

n|=(1<<34);

---

le 1 est pris comme un entier 32 bits, taille par défaut probable de ton compilateur.

Mettre

Code:

---

n|=(1ll<<34);

---

devrait résoudre le problème

(Pas testé, pas de compilateur sous la main)

oui, en fait oui.
ca marche.
merci.

j'ai l'air un peu ridicule du coup non ?

Citation:

---

Envoyé par xantares

je voudrais pouvoir utiliser les operateurs sur les bits : <<,|,&, sur des entiers de 64 bits (jeu d'echec) pour faire des masques...

bref, tous ces operateurs ne fonctionnent pas au-dessus de 32 bits, ci-dessous un code d'exemple : 1<<34 est affiché comme 0.

Comment s'en sortir, si-possible de maniere la plus portable possible (linux...)

---

Il faut utiliser un compilateur C99 :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <stdio.h> #include <stdlib.h>   #ifdef WIN32 #define LL "I64" #else #define LL "ll" #endif   int main (void) { unsigned long long n = 0;   n |= (1llu << 34); printf ("%" LL "x\n", n); return 0; }

---

Code:

---

1 2 3

400000000   Press ENTER to continue.

---

Pour la petite explication (tout ce qui suit n'est valable que pour la plupart des compilateurs 32 bits sur architecture 32 bits) :

Toute valeure constante à un type par défaut.

Par exemple :
- "hello world !" sera de type char*
- 1 sera de type int (type d'entier par défaut pour les littéraux en C)
- 1.0 sera de type double (type de flottants par défaut ...)
...

Ca c'est pour les types de constantes par défaut, maintenant le C permet de préciser d'autres types en ajoutant un ou des caractères à la suite (un peu comme les code %... de printf) :

- L"hello world !" sera vue comme une Wide String (wchar_t*)
- 1u sera vu comme un unsigned int
- 1l sera vu comme un long (qui est de même type que int, soit un entier 32 bits)
- 1ll sera vu comme un long long int (soit un entier 64 bits)
- 1.0f sera vu comme un float
- 1.0l sera vu comme un long double
...

Autres écritures possible :

Code:

---

1 2	1LLu << 34 1i64u << 34

---

Attention, pour architecture différente, un même code pourra donner des types d'entiers de longueur différente.

Salut,

Je présumes que l'intéret des 64 bits réside dans le fait que cela correspond exactement au nombre de case d'un échiquier...

Et, si ma présomption est juste (détrompes moi s'il le faut), ne serait il pas intéressant d'envisager les chose sous un autre angle:question:

Je m'explique:
Les considérations à prendre en compte sont que

• Chaque case peut avoir une piece, ou non
• chaque piece peut etre noire ou blanche
• chaque piece peut etre pion, tour, cavalier, fou, reine ou roi
• une piece ne peut aller sur une case que
  
  • si la case est vide
  • si la case est occupée par une piece d'une autre couleur
  • EDIT (pour etre complet) si la case sur laquelle elle veut aller correspond au déplacement qu'elle peut entreprendre

Dans ce cas, pourquoi ne pas créer une strucutre pour ta case qui contiendrait les différentes informations qui lui sont utiles (libre ou non, piece et couleur) et une matrice de cases 8*8 pour représenter l'échiquier:question:

Je présumes que tu as dores et déjà une structure du genre de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

enum type { pion, tour, fou, cavalier, reine, roi }; enum couleur { blanc, noir }; typedef struct s_piece { type t; couleur coul; /* voir si posx et posy ont un intérêt quelconque ;) */ int posx; /* position horizontale */ int posy; /* position verticale */ }piece;

---

La case deviendrait logiquement quelque chose du genre de

Code:

---

1 2 3 4 5 6 7

typedef struct s_case { piece* p;/*vaut NULL si la case est libre ;) */ }Cases; /* l'échiquier prend la forme de */ Cases echiquier[8][8];

---

De cette manière, tu pourrais définir si une piece peut aller sur une case sous la forme de

Code:

---

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

/* @in: la case de destination   la couleur de la piece qui veut y aller   @out: 0 si elle ne peut pas, 1 si la case est libre 2 si on prend une piece */ int CanGoTo(Cases dest,couleur coul) { /* si la case est libre, il n'y a pas de problème ;) */ if(dest.p==NULL) return 1; /* sinon, on refuse si elle est occupée par une piece de la meme couleur */ else if(dest.p->coul==coul) return 0; /* arrivé ici, la piece qui veut bouger en prend une autre ;) */ return 2; } /* utilisé sous la forme de */ switch(CanGoto(echiquier[y][x],p->coul) { case 2: /* on supprime la piece adverse qui s'y trouve */ free (echiquier[y][x].piece); /* on y met notre piece */ /* d'abord, on signale sa nouvelle position à la piece */ case 1:/*ce qui suit est commun pour 1 et 2 (==>pas de break   avant case 1 ;) )*/ p->posx=x; p->posy=y; echiquier[y][x]=p; break; case 0:/*que faire dans ce cas là ???   sans doute chercher une autre case où aller ;)*/ break; };

---

(tous codes non testés ;) )

Hoï,

Citation:

---

Envoyé par koala01

Je présumes que l'intéret des 64 bits réside dans le fait que cela correspond exactement au nombre de case d'un échiquier...

---

Je ne vois absolument rien dans le message de xantares qui te conduit à faire cette supposition.

Peut-être un autre sujet ?

Citation:

---

Envoyé par droggo

Je ne vois absolument rien dans le message de xantares qui te conduit à faire cette supposition.

---

Bah...

Citation:

---

je voudrais pouvoir utiliser les operateurs sur les bits : <<,|,&, sur des entiers de 64 bits (jeu d'echec) pour faire des masques...

---

Ho,

Citation:

---

Envoyé par Emmanuel Delahaye

Bah...

---

Comme quoi, lire trop vite conduit à des réponses trop rapides.

Citation:

---

Envoyé par droggo

Hoï,

Je ne vois absolument rien dans le message de xantares qui te conduit à faire cette supposition.

Peut-être un autre sujet ?

---

Simplement parce qu'il y a exactement 64 cases sur un jeu d'échec, qu'il parle d'utiliser une valeur 64bits pour faire des masques et qu'un des masques utils serait de savoir si la case est libre ou non...

Ceci dit, tu remarqueras que j'ai envisagé d'avoir un peu trop vite lu entre les lignes de sa demande en précisant "je présumes que..." et "si ce n'est pas le cas, détrompe moi" ;)