Enum la portée des questions

J'essaie de garder les choses aussi local que possible, j'ai donc mis les énumérations à portée de classe, même si elles sont partagées entre deux classes (je l'ai mis dans la classe qui "va mieux" avec elle.) Cela a très bien fonctionné, mais j'ai récemment rencontré un problème où une dépendance circulaire va se produire si j'ai mis l'enum à portée de classe.

L'enum est va être un argument du constructeur pour plusieurs classes, et la classe il est (et de la classe qui fait le plus de sens pour lui d'être dans) comprend les classes. Ainsi, il n'est pas possible d'utiliser les enum comme un argument du constructeur pour les classes incluses, car elle aura pour conséquence une dépendance circulaire.

Serait-il mieux de mettre juste ce enum dans son propre fichier d'en-tête, et si oui, dois-je mettre toutes les énumérations dans le fichier d'en-tête pour être cohérent? Existe-il d'autres solutions à ce problème (c'est logique)?

avez-vous essayé de déclaration?
Avant les déclarations seulement vous permettre d'accéder le nom du type. Vous ne pouvez pas accéder à l'interface ou de l'instancier ou de faire quelque chose comme ça.

InformationsquelleAutor Anonymous | 2009-11-15

c++enums scope

4

si l'enum est utilisé par plusieurs classes, alors je dirais qu'il n'appartient pas vraiment à la définition d'une classe unique, mais dans l'espace de noms dans lequel les classes de résidence.

c'est moins que l'énumération est passé par une classe du constructeur de l'autre, auquel cas il peut faire plus de sens pour instancier l'enum charge de la classe séparément et de les passer en paramètre au constructeur de la classe conteneur.
- La deuxième chose que vous avez décrit est le cas, mais la méthode décrite ne fonctionne pas. J'ai décidé de faire le énums disponible dans un utilitaire d'en-tête qui a des méthodes les plus couramment utilisées, etc.
InformationsquelleAutor dice
14

Depuis C++11, vous pouvez utiliser un enum class (ou enum struct - la même chose, a déclaré différemment), où les valeurs enum sont limitées à l'enum nom. Par exemple, ici, est valide en C++11 de la déclaration.
```
enum class token_type {
    open_paren,
    close_paren,
    identifier
};
```
Pour accéder aux valeurs de l'enum, cependant, vous devez portée correctement à l'aide de la :: de l'opérateur. Donc, c'est une assignation valide en C++11:
```
token_type type = token_type::close_paren;
```
Mais ce n'est pas:
```
token_type type = close_paren;
```
Cela résout le conflit de noms, et signifie que vous n'avez pas à utiliser le conteneur de l'espace de noms ou struct juste pour arrêter la portée des valeurs qui fuit à l'endroit où ils ne devraient pas. Cela signifie que l'enum ci-dessous peuvent exister dans le même champ d'application que token_type:
```
enum class other_enum {
    block,
    thingy,
    identifier
};
```
Maintenant les deux valeurs appelé identifier différente dans les deux structures ne sera pas interférer.

InformationsquelleAutor Tom Galvin
8

J'utilise une variante de ce que Michael et Roger n':
```
namespace Color
{
   enum Type
   {
      red,
      green,
      blue
   };
};

void paintHouse(Color::Type color) {...}

main()
{
   paintHouse(Color::red);
}
```
Je trouve Color::Type à être plus joli et plus d'auto-documentation de Color::Color ou COLOR::Color. Si vous trouvez Color::Type trop verbeux, vous pouvez utiliser Color::T.

Je n'ai pas de préfixe de mes valeurs énumérées (c'est à dire COLOR_RED) parce que l'espace de noms autour de l'enum devient le préfixe.

J'ai arrêté à l'aide de la ALL_CAPS convention pour mon étendue de constantes car ils se heurtent à des macros en C des bibliothèques (par exemple, la valeur NULL). Les Macros ne sont pas étendues dans les espaces de noms qu'ils sont définis dans.
- Je suis maintenant en considérant l'adoption de Matthieu M de la suggestion de l'aide struct au lieu de espace de noms pour être en mesure de passer comme un paramètre du modèle. Cependant, je ne peux pas penser à une raison pourquoi je préfère passer la Couleur au lieu de la Couleur::Type d'un paramètre du modèle.
- Je vais maintenant utiliser C++11 l'étendue des énumérations, mais j'espère que cette réponse est toujours utile pour ceux contraint de C++98/03.
InformationsquelleAutor Emile Cormier
3

J'ai souvent mis mes énumérations dans un espace de noms pour éviter les différentes valeurs enum d'encombrer l'espace de noms global. Je pense que c'est ce que vous essayez de le faire en les mettant dans une classe. Mais si ils ne correspondez pas bien dans une classe, un espace de noms fonctionne assez bien juste pour ce but:
```
namespace FooSettings
{
    enum FooSettings
    {
        foo,
        bar
    };
}
typedef enum FooSettings::FooSettings FooSettingsEnum;


int main()
{
    FooSettingsEnum x = FooSettings::foo;
};
```
J'ai un extrait de l'éditeur, qui fabrique les grandes lignes d'une nouvelle énumération, compte tenu de son nom, y compris le
```
typedef enum FooSettings::FooSettings FooSettingsEnum;
```
ligne qui crée un typedef, donc c'est un peu plus lisible de déclarer les variables avec l'énumération du type.

Je soupçonne que Stroustrup aurait fait la valeur de l'énumération des noms limitées à l'énumération s'il en avait l'occasion, mais C compatibilité forcé sa main (c'est juste de la spéculation - peut-être qu'un jour je vais regarder dans D&E et voir s'il parle de quoi que ce soit).
- Personnellement, je préfère un struct qu'un espace de noms parce qu'une structure est alors manipulable à partir de modèles.
- À l'aide d'un struct tout simplement jamais venu à l'esprit. Je ne peux pas dire que j'ai manqué de ne pas être capable de manipuler les énumérations avec des modèles, mais je vois pas d'inconvénient à l'utilisation d'une structure à envelopper l'enum de la portée, non plus. Encore une bonne idée pour moi de l'utiliser. Merci.
- J'ai essayé de l'encapsulation des énumérations dans un espace de noms et également dans une struct, et certaines choses fonctionnent mieux avec une struct. Donc je le fais souvent la suivante: struct MyEnum { les Valeurs de l'enum{a, b}; }; typedef MyEnum::les Valeurs MyEnum_t; Maintenant je peux utiliser MyEnum_t pour se référer à l'enum comme un type, et MyEnum::a, MyEnum::b à se référer à ses membres, comme si l'enum étaient un type de regroupement. J'ai expérimenté un certain temps avant de choisir la particulier les conventions de nommage ici et j'ai plus de temps pour être aussi bon que je peux faire.
InformationsquelleAutor Michael Burr
2

Vous devez placer les enum, en dehors de toute classe, si elle est partagée, mais vous pouvez encore le champ d'application du protocole enum. Le placer dans l'espace de noms afin de les agents recenseurs ne pas "fuir", qui encombrent votre projet d'espace de noms:
```
namespace Project { //you already have this, right? :)
  namespace COLOR { //naming styles differ, use what you like
    enum Color {
      red,
      green,
      blue
    };
  }
  using COLOR::Color; //now you can use the type 'normally'

  //examples:
  struct A {
    Color c;
    A() : c(COLOR::red) {}
  };
  void f(Color c) {
    using namespace COLOR;
    //inside this function, we no longer have to prefix COLOR::
    if (c == green) {
      go();
    }
    else if (c == red) {
      stop();
    }
  }
}
```
- Je vais essayer d'utiliser le using s=déclaration comme vous le faites pour voir si je l'aime mieux que la typedef mess que j'ai utilisé. Je pense que je vais l'aime (mais peut utiliser une autre convention de nommage que tous les chapeaux pour le type enum). Merci!
- J'ai utilisé des BOUCHONS parce qu'il semblait que la Couleur serait plus utilisé que la COULEUR::rouge, ou si vous voulez utiliser souvent ces derniers et pouvez utiliser un aide-directive à portée de la fonction. typedef COLOR::Color Color; est équivalent à using COLOR::Color; ici.
InformationsquelleAutor
2

Je suis d'accord avec Emile. Une autre option si vous êtes à l'aide de C++98 est d'utiliser struct au lieu de espace de noms, comme suit
```
struct Color
{
   enum Type
   {
    red,
    green,
    blue
   };
};
```
Je préfère depuis idéalement, j'aimerais utiliser un espace de noms pour représenter un module qui contient plusieurs classes, plutôt que de simplement la portée d'un enum ...

InformationsquelleAutor HazemGomaa
-2

Vous pouvez essayer de le déclarer avant la enum comme ceci:
```
enum MyEnum;
```
- Les énumérations ne peut pas être déclaré avant.
- Et même si vous le pouviez, vous ne pouvez pas déclarer avant les types imbriqués. Ou plutôt, vous ne pouvez pas déclarer avant un type imbriqué sans avoir la définition du type d'imbrication.
- Comme une note historique, depuis C++11, vous pouvez l'avant-déclarer un enum class (ou enum struct), mais ils sont distincts de style ancien enums.
InformationsquelleAutor gatorfax

Vous devez vous connecter pour publier un commentaire.