Enum problème "copie"

Question

J'ai une classe, nous allons l'appeler A. Il a une ENUM (E) et une méthode Foo (E e), avec E obtient dans les arguments. Je veux écrire un wrapper (décorateur) W pour A. Donc ça va avoir sa propre méthode Foo (A :: E). Mais je veux avoir une sorte d'encapsulation, donc cette méthode devrait être définie comme Foo (F f), où F est une autre enum définie dans W, qui peut être convertie en A :: E. Par exemple:

class A 
{ 
    public: 
    enum E { ONE, TWO, THREE }; 
    void Foo(E e); 
}; 

class B 
{ 
    //enum F; // ??? 
    void Foo(F f) 
    { 
    a_.Foo(f); 
    } 

    private: 
    A a_; 
}; 

Comment F doit être défini? Je ne veux pas copier la valeur comme ceci:

enum F { ONE = A::ONE, TWO = A::TWO, THREE = A::THREE }; 

parce que son erreur potentielle dans la fonction proche. La définition de typedef:

typedef A::E F; 

est la meilleure décision? Est-ce légal?

Answer 1

Je pense que pour améliorer la simplicité de votre programme, le meilleur des deux choix que vous avez présentés est d'utiliser le typedef à moins qu'il y ait une raison impérieuse de ne pas le faire. Je ne recommande certainement pas la fonctionnalité de duplication (comme votre première approche semble faire) car cela devient rapidement un problème de maintenance.

Answer 2

Le problème avec le typedef est qu'il ne fait pas disparaître A. Vous ne seriez pas capable de dire F f = B::ONE;, car B :: ONE n'existerait pas. Vous devez toujours utiliser A :: ONE, etc. D'après ce que je comprends, ce n'est pas ce que vous voulez.

Pour ce que vous croyez, créer une nouvelle énumération en B est probablement votre meilleur pari. Les seules choses à se méfier ici sont 1) vous devrez taper cast entre A :: E et B :: F et 2) les changements dans une énumération doivent être reflétés dans l'autre.

Il ne serait pas nécessaire de copier les valeurs comme vous le faites. Si A :: E était:

enum E { ONE = 4, TWO = 7, THREE, FOUR, FIVE }; 

Vous pouvez ensuite copier et coller ce pour créer B :: F:

enum F { ONE = 4, TWO = 7, THREE, FOUR, FIVE }; 

Cependant, l'inconvénient de cette copie & pâte est que si je décide alors pour changer A :: TWO pour être égal à dix, je devrais être sûr de changer B :: TWO. Si vous définissiez B :: F de la façon dont vous avez montré (ONE = A :: ONE ...), ce ne serait pas un problème mais ce serait un peu plus de travail.