Comment fait-on pour d=E9clarer un enum ? (...est-ce seulement
possible ?)
En pratique, je souhaite diminuer les d=E9pendances (et surtout les
temps de compilation, sans sacrifier les problemes de maintenance et
de perf) dans une situation du type suivant (il s'agit =E0 peu pr=E8s
d'une factory) :
dans un "OperationManager.h" j'ai le code suivant :
class OperationBaseClass;
/* Si OP_ID =E9tait une classe, j=E9crirais "class OP_ID;" ici */
class OperationManager {
public :
OperationManager();
~OperationManager();
void register(OP_ID /*&*/ e, OperationBaseClass* op);
=2E..
};
#endif
j'ai un "op_id.h" qui contient :
typedef enum { OP0 =3D 0, OP1, OP2, OP3 , END} OP_ID;
j'ai =E9galement un "OperationBaseClass.h"
le OperationManager.cpp commence ainsi :
#include "OperationManager.h"
#include "OperationBaseClass.h"
#include "OperationDerive0.h"
#include "OperationDerive1.h"
#include "OperationDerive2.h"
#include "op_id.h"
OperationManager::OperationManager() {
register(OP0, new OperationDerive0());
register(OP1, new OperationDerive1());
register(OP2, new OperationDerive2());
/* ... */
}
dans la d=E9claration de OperationManager::register, je pourrais
remplacer OP_ID par int et faire ensuite un cast de int vers OP_ID.
Y-a-t-il une solution (autre que de mettre la d=E9finition de l'enum
dans OperationManager.h) sans cast ?
class OperationBaseClass; /* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui fournit aussi les operations necessaires pour servir de cle dans la factory (au hasard, semantique de valeur et operateurs de comparaison).
dans un "OperationManager.h" j'ai le code suivant :
class OperationBaseClass;
/* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer
OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui
fournit aussi les operations necessaires pour servir de cle dans la
factory (au hasard, semantique de valeur et operateurs de comparaison).
class OperationBaseClass; /* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui fournit aussi les operations necessaires pour servir de cle dans la factory (au hasard, semantique de valeur et operateurs de comparaison).
ALB
On 5 jan, 14:24, Michel Decima wrote:
dans un "OperationManager.h" j'ai le code suivant :
class OperationBaseClass; /* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui fournit aussi les operations necessaires pour servir de cle dans la factory (au hasard, semantique de valeur et operateurs de comparaison).
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
On 5 jan, 14:24, Michel Decima <michel.dec...@wanadoo.fr> wrote:
dans un "OperationManager.h" j'ai le code suivant :
class OperationBaseClass;
/* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer
OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui
fournit aussi les operations necessaires pour servir de cle dans la
factory (au hasard, semantique de valeur et operateurs de comparaison).
C'est ce que je souhaite éviter en fait.
L'idée de l'enum était de rester simple et de stocker les
OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne
pas utiliser de map.
class OperationBaseClass; /* Si OP_ID était une classe, jécrirais "class OP_ID;" ici */
En prenant cette remarque au pied de la lettre : tu pourrais transformer OP_ID en une vraie classe, qui se contente d'encapsuler un enum, et qui fournit aussi les operations necessaires pour servir de cle dans la factory (au hasard, semantique de valeur et operateurs de comparaison).
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
Michel Decima
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h class OperationBaseClass; class OperationKey;
class OperationManager { public: void register( OperationKey& e, OperationBaseClass* op ); };
// OperationKey.h #include "op_id.h"
struct OperationKey { OperationKey( OP_ID e ) : value( e ) {} OP_ID value; };
C'est ce que je souhaite éviter en fait.
L'idée de l'enum était de rester simple et de stocker les
OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne
pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h
class OperationBaseClass;
class OperationKey;
class OperationManager {
public:
void register( OperationKey& e, OperationBaseClass* op );
};
// OperationKey.h
#include "op_id.h"
struct OperationKey {
OperationKey( OP_ID e ) : value( e ) {}
OP_ID value;
};
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h class OperationBaseClass; class OperationKey;
class OperationManager { public: void register( OperationKey& e, OperationBaseClass* op ); };
// OperationKey.h #include "op_id.h"
struct OperationKey { OperationKey( OP_ID e ) : value( e ) {} OP_ID value; };
ALB
On 5 jan, 15:28, Michel Decima wrote:
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h class OperationBaseClass; class OperationKey;
class OperationManager { public: void register( OperationKey& e, OperationBaseClass* op );
};
// OperationKey.h #include "op_id.h"
struct OperationKey { OperationKey( OP_ID e ) : value( e ) {} OP_ID value;
};- Masquer le texte des messages précédents -
- Afficher le texte des messages précédents -
C'est un très joli contournement que je vais sans doute retenir (ça m'apprendra à avoir mis au bagne les classes qui font des conversions implicites). Je perds neanmoins une copie d'entier : c'est terrible ;-)...
Merci.
Adrien
On 5 jan, 15:28, Michel Decima <michel.dec...@wanadoo.fr> wrote:
C'est ce que je souhaite éviter en fait.
L'idée de l'enum était de rester simple et de stocker les
OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne
pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h
class OperationBaseClass;
class OperationKey;
class OperationManager {
public:
void register( OperationKey& e, OperationBaseClass* op );
};
// OperationKey.h
#include "op_id.h"
struct OperationKey {
OperationKey( OP_ID e ) : value( e ) {}
OP_ID value;
};- Masquer le texte des messages précédents -
- Afficher le texte des messages précédents -
C'est un très joli contournement que je vais sans doute retenir (ça
m'apprendra à avoir mis au bagne les classes qui font des conversions
implicites).
Je perds neanmoins une copie d'entier : c'est terrible ;-)...
C'est ce que je souhaite éviter en fait. L'idée de l'enum était de rester simple et de stocker les OperationBaseClass* dans un OperationBaseClass* _array[END] et de ne pas utiliser de map.
Ok. Dans ce cas, tu pourrais faire ceci:
// OperationManager.h class OperationBaseClass; class OperationKey;
class OperationManager { public: void register( OperationKey& e, OperationBaseClass* op );
};
// OperationKey.h #include "op_id.h"
struct OperationKey { OperationKey( OP_ID e ) : value( e ) {} OP_ID value;
};- Masquer le texte des messages précédents -
- Afficher le texte des messages précédents -
C'est un très joli contournement que je vais sans doute retenir (ça m'apprendra à avoir mis au bagne les classes qui font des conversions implicites). Je perds neanmoins une copie d'entier : c'est terrible ;-)...
Merci.
Adrien
James Kanze
On Jan 5, 1:58 pm, ALB wrote:
Comment fait-on pour déclarer un enum ? (...est-ce seulement possible ?)
Sans énumérer ces membres ? Ce n'est pas possible -- même si le type est incomplet, on peut définir un pointeur à lui, et sur certaines architectures (assez exotiques aujourd'hui), il faut que le compilateur sache les membres pour savoir la taille du pointeur.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Jan 5, 1:58 pm, ALB <lebatt...@crans.org> wrote:
Comment fait-on pour déclarer un enum ? (...est-ce seulement
possible ?)
Sans énumérer ces membres ? Ce n'est pas possible -- même si le
type est incomplet, on peut définir un pointeur à lui, et sur
certaines architectures (assez exotiques aujourd'hui), il faut
que le compilateur sache les membres pour savoir la taille du
pointeur.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Comment fait-on pour déclarer un enum ? (...est-ce seulement possible ?)
Sans énumérer ces membres ? Ce n'est pas possible -- même si le type est incomplet, on peut définir un pointeur à lui, et sur certaines architectures (assez exotiques aujourd'hui), il faut que le compilateur sache les membres pour savoir la taille du pointeur.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
