Types de données énumérés et API de classe en C++

Question

Si vous êtes censé encapsuler tout dans une définition de classe, comment est-il possible d'utiliser des types de données énumérés avec la classe? Par exemple, je viens d'écrire le code suivant ...

enum PizzaType {DEEP_DISH, HAND_TOSSED, PAN}; 
enum PizzaSize {SMALL, MEDIUM, LARGE}; 

class Pizza { 
    public: 
     Pizza(); 
     void setPizzaType(PizzaType type); 
     PizzaType getPizzaType(); 
     void setPizzaSize(PizzaSize size); 
     PizzaSize getPizzaSize(); 
     void setToppings(int toppings); 
     int getToppings(); 
     void outputDescription(); 
     double computePrice(); 
    private: 
     PizzaType pizzaType; 
     PizzaSize pizzaSize; 
     int totalToppings; 
}; 

Est-il possible d'inclure les types de données énumérés dans la classe elle-même et permettre encore toujours accès aux fonctions mutator/accesseurs de l'extérieur?

Answer 1

Ce n'est pas un problème, vous pouvez créer des variables de ce type enum en spécifiant Pizza :: PizzaType. Mettez les énumérations à l'intérieur de votre classe, si vous voulez qu'elles soient accessibles par l'extérieur, assurez-vous qu'elles sont publiques aussi.

Pizza p; 
p.setPizzaType(Pizza::PAN); 
Pizza::PizzaType pt = p.getPizzaType(); 
assert(pt == Pizza::PAN); 

Answer 2

Tant que le type d'énumération est publique, vous êtes autorisé à l'utiliser en dehors de la classe. Vous avez juste à le définir i: Pizza :: PizzaType. La même règle existe pour les méthodes statiques et pour les constantes et variables statiques.

Answer 3

Vous pouvez définir l'énumération à l'intérieur de la classe et l'utiliser à l'extérieur, comme vous utilisez un espace de noms, c'est-à-dire classname :: enum_type. En fait, c'est une bonne idée de le définir à l'intérieur de la classe car cela évite la pollution de l'espace de noms global.

Answer 4

class Pizza { 
    public: 
     enum PizzaType {DEEP_DISH, HAND_TOSSED, PAN}; 
     void setPizzaType(PizzaType type); 
     PizzaType getPizzaType(); 
}; 
... 
Pizza p; 
p.setPizzaType(Pizza::DEEP_DISH); 
Pizza::PizzaType pt = p.getPizzaType(); 

Answer 5

Oui, vous pouvez le faire comme ceci:

class Pizza { 
    public: 
     enum PizzaType {DEEP_DISH, HAND_TOSSED, PAN}; 
     enum PizzaSize {SMALL, MEDIUM, LARGE}; 

     Pizza(); 
     void setPizzaType(PizzaType type); 
     PizzaType getPizzaType(); 
     void setPizzaSize(PizzaSize size); 
     PizzaSize getPizzaSize(); 
     void setToppings(int toppings); 
     int getToppings(); 
     void outputDescription(); 
     double computePrice(); 
    private: 
     PizzaType pizzaType; 
     PizzaSize pizzaSize; 
     int totalToppings; 
}; 

.. et d'autres ont dit, il vous suffit d'utiliser le « espace de noms » Pizza afin d'obtenir les types de ENUM:

Pizza::PizzaType tmp = pPizza->getPizzaType(); 

etc, etc.

(comme une note de style, quand vous mettez les énumérations à l'intérieur de la cette classe comme, je le ferais retirer personnellement la pizza devant elle afin que vous ayez Pizza :: Type et Pizza :: Size)

Answer 6

La méthode préférée d'utilisation énumérations en C++ est de les définir dans une classe.

class Foo { 
public: 
    enum Bar { 
     ENUM_VALUE1, 
     ENUM_VALUE2 
    }; 
}; 

ensuite, vous pouvez les référencer en utilisant:

Foo::Bar var; 
var = Foo::ENUM_VALUE1; 

A l'intérieur de la classe, vous pouvez laisser tomber le préfixe Foo::.

Comme vous l'avez probablement remarqué, alors que le type de l'énumération est Foo::Bar, les valeurs ne sont pas référencées par Foo::Bar::ENUM_VALUE1, mais apparaissent plutôt dans l'espace de noms Foo. Cela peut être problématique si différentes énumérations partagent les mêmes noms de valeur. Pour éviter cela, vous pouvez faire l'astuce suivante:

class Foo { 
public: 
     struct Bar { 
      enum ENUM { 
        ENUM_VALUE1, 
        ENUM_VALUE2 
      }; 
     struct Baz { 
      enum ENUM { 
        ENUM_VALUE1, 
        ENUM_VALUE2 
      }; 
     }; 
}; 
Foo::Bar::ENUM e = Foo::Bar::ENUM_VALUE1; 
Foo::Baz::ENUM e2 = Foo::Baz::ENUM_VALUE1;