Boucler le contenu d'un ENUM

Version imprimable

Bonjour à tous,

Je suis en train de créer un petit jeu d'échecs afin de créer une IA.
Pour représenter les positions j'ai fait 2enums :

- POS_LETTER
- POS_NUMBER
Code:

1 2 3 4 5 6 7 8 enum POS_LETTER { POS_A = 1, POS_B = 2, POS_C = 3, POS_D = 4, POS_E = 5, POS_F = 6, POS_G = 7, POS_H = 8 };
Maintenant j'utilise donc pour créer des positions ce type de code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Position { public: Position(POS_LETTER, POS_NUMBER); // Constructeur private: POS_LETTER letter; POS_NUMBER number; };
Jusqu'ici tout fonctionne bien mais le problème est que j'aimerai pouvoir boucler sur ces positions et faire donc un for dessus :

Code:

for(POS_LETTER letterPawn=POS_A; letterPawn<=POS_H; letterPawn++)

Mais j'ai une erreur sur l'opérateur++ inconnu pour POS_LETTER, ce qui est fortement compréhensible.. J'aimerai donc savoir comment je peux mis prendre pour boucler le contenu d'un enum ??

Merci à tous.

PS: Bien sur je pourrais faire un simple for(int i=1; i<=8; i++) mais ce n'est pas ce que je cherche...

31/08/2010, 18h02
Aleph69

Bonjour,

cette précédente discussion devrait t'aider.
31/08/2010, 20h55
CactO_o's

Je ne peux pas vraiment me satisfaire de cette réponse car il faut convertir en int qui vont se suivre 0,1,2,3,...
Et j'ai des cas ou les valeurs sont par exemple égales à 1,3,3,5,9,...

Il n'y a aucune autre solution ??

Bonsoir,

si ça te convient, tu peux ne pas utiliser d'énumération mais des variables constantes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class POS_LETTER { public: short const POS_A = 1; short const POS_B = 2; short const POS_C = 3; short const POS_D = 4; short const POS_E = 5; short const POS_F = 6; short const POS_G = 7; short const POS_H = 8; };
Dans ce cas, tu peux utiliser le patron de singleton pour n'instancier qu'une seule fois ta classe (cf la faq).
Tu peux aussi faire ta propre classe d'énumération! :mrgreen:

31/08/2010, 21h22
CactO_o's

Ouai c'est vrai que ça peut être intéressant, mais je penses que niveau performance il y aura pas mal de perte...

Sinon je peux faire une fonction nextPos qui retourne la position suivante... Qui reviendrai à recréer un operator++, en parlant de ça.. Ce n'est pas possible de l'ajouter à l'énumération ?? Comme ça se serait réglé :p
31/08/2010, 21h30
Aleph69

Citation:

Envoyé par CactO_o's

Sinon je peux faire une fonction nextPos qui retourne la position suivante... Qui reviendrai à recréer un operator++, en parlant de ça.. Ce n'est pas possible de l'ajouter à l'énumération ?? Comme ça se serait réglé :p

Ca me paraît contre-nature mais sinon je ne sais pas s'il est techniquement possible de surcharger l'opérateur ++ pour une énumération.
Tu devrais essayer par toi-même.

Entre nous, l'argument des performances ne tient pas ici parce que ton énumération va contenir peu de valeurs.
31/08/2010, 21h48
CactO_o's

Ouai c'est vrai que ça peut être intéressant, mais je penses que niveau performance il y aura pas mal de perte...

Sinon je peux faire une fonction nextPos qui retourne la position suivante... Qui reviendrai à recréer un operator++, en parlant de ça.. Ce n'est pas possible de l'ajouter à l'énumération ?? Comme ça se serait réglé :p

Salut,

Je me demande si tu ne prends pas le problème à l'envers:

Dans un jeu d'échec, tu as 64 positions valides qui ne changent absolument pas (de A1 à H8), et qui acceptent de recevoir une pièce de l'échiquier.

Lorsqu'une pièce se déplace, il se s'agit pas de modifier la position à laquelle la pièce se trouve, mais bel et bien de changer de position.

Pièces et positions sont créées "une bonne fois pour toutes" au moment du lancement du jeu .

Comme il est tout aussi possible qu'une position n'ait pas de pièces qui se trouve sur elle, il est possible qu'une pièce ne se trouve sur aucune position (quand elle a été prise). La relation pièce <--> position doit donc en tenir compte (utiliser des pointeurs pour représenter cette relation ;))

Une pièce doit pouvoir renvoyer la position à laquelle elle se trouve et une position doit pouvoir renvoyer la pièce qui se trouve dessus, s'il y en a une.

Une position doit, également simplement renvoyer sa position en verticale (lettres) et horizontale (chiffres) et, essentiellement, être comparée à une autre en terme d'égalité.

Un échiquier maintient un ensemble de 64 position et est en mesure de renvoyer un pointeur vers l'une d'elle en particulier sur base des positions horizontales et verticales ( Position *getPosition(POS_LETTER, POS_NUMBER) )

Il maintient également un ensemble de pièces susceptibles de se trouver sur l'échiquier.

Un joueur reçoit un ensemble de pièces, correctement placées sur l'échiquier, en début de partie et s'occupe de les faire se déplacer.

Il doit faire la distinction entre les pièces encore présentes sur l'échiquier et celle que son adversaire lui a prises.

Une partie s'occupe de gérer les deux joueurs et de leur donner l'ensemble de pièces adéquat.

Son rôle est de veiller au bon déroulement d'une partie.

Au final, tu aurais quelque chose de proche de

les énumérations sympa

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum POS_LETTER {   POS_A = 1,
                    POS_B = 2,
                    POS_C = 3,
                    POS_D = 4,
                    POS_E = 5,
                    POS_F = 6,
                    POS_G = 7,
                    POS_H = 8 };
enum POS_NUMBER {   POS_1 = 1,
                    POS_2 = 2,
                    POS_3 = 3,
                    POS_4 = 4,
                    POS_5 = 5,
                    POS_6 = 6,
                    POS_7 = 7,
                    POS_8 = 8 };
enum Color
{
    white =0,
    black
};

les positions

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
class Position
{
    friend class Game;
    public:
        Position( POS_LETTER x, POS_Number y):
        bool hasPiece() const{return piece_!=NULL;}
        Piece * piece(){return piece_;}
        void pieceIn(Piece* p)
        {
            /* s'il y a déjà une pièce sur cette position, elle est prise
             * par l'adversaire et elle se trouve donc sur "aucune position"
             */
             if(piece_ && piece_!=p)
                 piece_->leave(NULL);
              piece_ = p;
        }
        void pieceOut(); // quand une pièce part
        {
             piece_=NULL;
        } 
        POS_LETTER verticlaPos() const{return letter;}
        POS_NUMBER horizontalPos() const{return number;}
    private:
        POS_LETTER letter;
        POS_NUMBER number;
 
        Piece * piece_;
};

les pieces

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
class Piece
{
    friend class Game;
     public:
         Piece(Position * p, Color c):position_(p),color_(c){}
         virtual ~Piece(){}
         /* permet de s'assurer qu'un déplacement est autorisé
          * par le type réel de la piece (à implémenter pour 
          * chaque type de pièce dérivé ;))
          */
         virtual bool followRules(Position target) const = 0;
         bool isAlive() const{return position_!=NULL;}
         bol leave(Position * destination)
         {
             if(!followRules(destination))
                 return false;
             if( destination && ! canMove(destination)
                 return false; // on essaye d'aller sur une position "amie"
             position_->pieceOut(); // signale à la position actuelle que la
                                    // piece part
             position_ = destination;
             if(position_)
                 position_->pieceIn(this); // signale à la destination que la piece
                                           // arrive dessus (si elle n'a pas été prise)
             return true;
         }
         bool canMove(Position * target)
         {
             Piece * temp=target->piece();
             return (temp && temp->color()!=color_) || temp==NULL;
         }
         Color color() const{return color_;}
         Position * position() const{return position_;}
};

Les classes dérivées

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
35
36
37
38
39
40
41
42
class Pion : public Piece
{
    public:
        Pion(Position* , Color);
        virtual ~Pion();
        virtual bool followRules() const;
};
class Roi: public Piece
{
    public:
        Roi(Position* , Color);
        virtual ~Roi();
        virtual bool followRules() const;
};
class Dame : public Piece
{
    public:
        Dame (Position* , Color);
        virtual ~Dame ();
        virtual bool followRules() const;
};
class Tour: public Piece
{
    public:
        Tour(Position* , Color);
        virtual ~Tour();
        virtual bool followRules() const;
};
class Cavalier : public Piece
{
    public:
        Cavalier (Position* , Color);
        virtual ~Cavalier ();
        virtual bool followRules() const;
};
class Fou : public Piece
{
    public:
        Fou (Position* , Color);
        virtual ~Fou ();
        virtual bool followRules() const;
};

Il manque sans doute pas mal de chose, dont les classes Echiquier et Partie, mais je ne vais pas tout faire pour toi ;)

Je fais généralement un truc comme ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct NomEnum {
    enum type {zero, un, deux, MAX__ };
    static type next(type e_) {
        assert(e_ < MAX__);
        return type(e_+1);
    }
    static std::string /* ou char const*, c'est selon */ toString(type e_);
    static type toEnum(std::string const& s);
};
 
....
for (NomEnum::type e = NomEnum::type() ; e != NomEnum::MAX__ ; e = NomEnum::next(e) ) {
    ...
}

D'autres framework (y compris le futur standard) apportent d'autres solutions. Perso, j'utilise mon générateur de code préféré (i.e. gvim)

Mais ... +1 à koala