Bonsoir,

Je vous contactes ce soir car j'ai une importante question par rapport à la façon de coder que je suis entrain d'adopter.

Donc avant de l'adopter définitivement, je tenais à me renseigné si c'est une belle façon de coder. En quelque sorte, si la communauté des développeurs ne va pas hurler en voyant comment je code.

Voici ce que j'appelle un Flag (là encore, je ne suis pas sûr d'utiliser le bon mot) :

#define CMD         char

#define CMD_NULL        0x00

#define CMD_RESET       0xEF

#define CMD_UP          0x01
#define CMD_DOWN        0x02
#define CMD_RIGHT       0x04
#define CMD_LEFT        0x08
#define CMD_JUMP        0x10

Sur une fonction qui utilise le type "CMD", je vais pouvoir passer énormément de valeurs booléennes différents. Par exemple si l'utilisateur appuie sur la touche destinée à avancer, et sur la touche droite, j'aurais un CMD = CMD_UP|CMD_RIGHT. On peut facilement retrouver les éventements avec l'opérateur binaire & (cmd&CMD_UP = true si cmd as le bit CMD_UP à 1).

J'ai l'impression que c'est vraiment une excellente technique pour passer des booléens ayant un rapport entre eux. Dites moi si c'est une bonne technique

J'ai poussé le concept encore plus loin avec un mélange binaire et entier non signé :

#define ANISIG                  unsigned int 

#define ANISIG_RESTART          0x0000
#define ANISIG_END              0x1000
#define ANISIG_SINGLE_FRAME      0x3000
#define ANISIG_INVERSE          0x4000

#define ANISIG_GOTO(ani)        ((ani&0x0FFF)|0x8000)

J'ai crée ce Flag pour gérer un sprite. en effet, apres la lecture d'une séquence d'images, il faut savoir que faire : refaire la séquence, aller a une certaine séquence, la refaire dans l'autre sens...

Alors j'ai définit deux parties dans mon flag. Une pour contenir, l'entier, et l'autre pour contenir les booléens.

Sur ce type de "Flag" j'ai pas mal de doutes a l'utiliser... En effet, on fais un mélange d'entiers et de booléens dans une même variable.

Merci d'avoir lu

-
Edité par >KryptOs_ 6 septembre 2018 à 19:18:53

>J'ai l'impression que c'est vraiment une excellente technique

Non, c'est un vieux machin tout moisi venu du C, pas du C++.

Google est ton ami :

https://stackoverflow.com/questions/1448396/how-to-use-enums-as-flags-in-c

https://en.cppreference.com/w/cpp/utility/bitset

>J'ai poussé le concept encore plus loin avec un mélange binaire et entier

Bin pousses le machin jusqu'à une belle structure, avec des champs bien explicites et facile à manipuler.

Salut,

Que penserais tu de

enum CMD : char{
/* ou mieux encore :
enum class CMD : char{
*/
NULL        0x00
 
RESET       0xEF
 
UP          0x01
DOWN        0x02
RIGHT       0x04
LEFT        0x08
JUMP        0x10
};
inline CMD operator & (CMD const & a , CMD const & b){
    assert(a == UP && b != DOWN && "Make your choice: up or down?");
    assert(a == DOWN && b != UP && "Make your choice: up or down?");
    assert(a == LEFT && b != RIGHT && "Make your choic: left or right?");
    assert(a == RIGHT && b != LEFT && "Make your choic: left or right?");
    return static_cast<CMD>(static_cast<char>(a) & static_cast<char>(b));

inline CMD operator |  (CMD const & a , CMD const & b){
    assert(a == UP && b != DOWN && "Make your choice: up or down");
    assert(a == DOWN && b != UP && "Make your choice: up or down");
    assert(a == LEFT && b != RIGHT && "Make your choic: left or right?");
    assert(a == RIGHT && b != LEFT && "Make your choic: left or right?");
    return static_cast(static_cast(a) | static_cast(b));

Ca reviendrait strictement au même, mais en C++ et non en C

-
Edité par koala01 7 septembre 2018 à 3:52:20