Discussion :

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

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

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

[droggo]

Hi,

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 :

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

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 :

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

  n|=(1<<34);

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

Mettre

Code :

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

  n|=(1ll<<34);

devrait résoudre le problème

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

[xantares]

oui, en fait oui.
ca marche.
merci.

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

[Emmanuel Delahaye]

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 :

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

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

1
2
3
400000000
 
Press ENTER to continue.

[mchk0123]

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 :

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

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.

[koala01]

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

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

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

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

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

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 :

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
 
/* @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 )

[droggo]

Hoï,

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 ?

[Emmanuel Delahaye]

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

Bah...

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

[droggo]

Ho,

Bah...

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

[koala01]

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"