Où mettre l'enum dans un programme cpp?

J'ai un programme qui utilise des types enum.

enum Type{a,b,};


class A
{
 //use Type
};
class B
{
  //also use that Type
};

2 classe sont situées dans 2 fichiers différents.
Dois-je mettre de la définition de type dans une headfile ou
dans la définition de classe pour chaque classe?

Voir stackoverflow.com/questions/902095/...
Pas tout à fait la même question, à mon humble avis.
Je ne suis pas sûr que c'est une copie exacte. Cette question se réfère à un enum qui n'appartiennent à aucune structure, mais il est utilisé dans les deux classes. L'autre question qui se rapporte à l'utilisation d'un enum d'une structure dans une autre structure.
Je pense que c'est le même sujet: "vais-je mettre la déclaration d'enum dans une classe et reportez-vous à la place de l'autre, ou le mettre dans ni et de la consulter de les deux, ou peut-être le mettre dans une classe de base commune, ou ...?". Je pense qu'ils ont tous deux la même réponse[s] même s'ils ne sont pas les deux les mêmes questions originales.

InformationsquelleAutor | 2009-06-14

c++

43

Si l'enum est destiné à être utilisé dans plus d'un .fichier cpp, vous devriez le mettre dans un fichier d'en-tête qui sera fourni par chacun. Si il y a un en-tête commun de fichier, vous devez l'utiliser, sinon vous pouvez tout aussi bien créer un nouveau fichier d'en-tête pour cette enum

InformationsquelleAutor Nathan Fellman
7

Vous devriez toujours essayer de limiter la portée de types en C++, donc l'enum doit probablement être declaread à portée de classe. L'enum sera appartiennent généralement légèrement plus naturellement dans une classe que l'autre, permet de dire que la classe A, afin de vous mettre dans la déclaration de Un en un.h en-tête:
```
//a.h

class A {
    public:
       enum Type { a, b };
    ...
};
```
Maintenant, vous devez inclure une.h dans l'en-tête qui déclare B:
```
//b.h
#include "a.h"

class B {
   public:
      void f( A::Type t );     //use the Type enum
   ...
};
```
- Cela dépend vraiment de la situation. Il n'y a rien d'intrinsèquement mauvais avec déclarer enum en dehors de la classe, et dans de nombreux cas, c'est une solution privilégiée. Notez que vous devriez essayer de limiter les dépendances inutiles.
- Il y aura une dépendance s'il est ou non dans une classe. En regardant mon propre code, je n'ai pas trouvé de cas où les énumérations sont déclarées à l'extérieur d'une classe.
- Mais il y a une différence entre une dépendance sur ce que vous avez juste besoin d' (enum) et de la dépendance sur le reste de la classe A, qui n'est pas pertinent et viole le principe de la connaissance au moins.
- Eh bien, nous n'en savons pas assez sur A et B pour dire quelque chose d'utile. Dans mon propre code, si une classe utilise une classe enum (et toutes mes énumérations sont de la classe des enums), il utilise toujours les autres caractéristiques de l'enum contenant de la classe. Mais YMMV.
- Sans en savoir plus, je dirais que le fait de mettre l'enum avec A ou B crée inutilement l'interface de la dépendance de l'un à l'autre. Mieux faire de A et B au même niveau de dépendance (les deux incluant un en-tête distincte qui définit des constantes, etc), sauf s'il est déjà explicite interface de la dépendance entre la classe (par opposition à mise de dépendances, qui sont beaucoup plus faciles à traiter).
InformationsquelleAutor
3

Je peux voir le point de Neil: c'est une bête noire pour de nombreux programmeurs de voir des trucs sur la portée globale. otoh, que, à mon humble avis, l'introduction d'une classe juste pour un enum n'est pas un bon style: Il est censé être enum pas une classe. Cependant, mettre la même enum liste dans les deux classes (est-ce que vous demandez) serait la pire idée: nous ne voulons pas répéter des choses.

En outre, dans la plupart des non-trivial codes, on risquerait de se retrouver en utilisant de plus de ce partage d'entités (plus enums, const paramètres, etc...) pour la mise en œuvre. Donc, j'avais commencer à regrouper tout cela dans une mise en espace de noms (dire "détail"), qui est un enfant de l'espace de noms des classes, et réside dans un autre fichier d'en-tête (dire "détail.hpp"), compris par tous. Par exemple:
```
//file A.hpp 
#include "foo/detail.hpp"
namespace foo {
   class A 
   { 
   //accessing enum as detail::a 
   };
}

//file B.hpp
#include "foo/detail.hpp"
namespace foo { class B { ... }; }  

//file foo/detail.hpp
namespace foo { namespace detail {
   enum { a,b, ... }
   const int three = 3;
   //etc...
   //other implementation classes etc...
}}
```
Et "détail" est agréable et propre façon de mettre en garde vos utilisateurs de mettre fin à ce qui est déclaré dans il. En tant que votre code est plus grand et ces détails de mise en œuvre commencer à croître en nombre, vous pouvez briser les dépendances de séparer les fichiers d'en-tête (detail1 detail2 etc...) et de toujours garder un "détail" de l'espace de noms (quelque chose que vous ne pouvez pas faire avec une classe "détail" par exemple).

InformationsquelleAutor sly
1

La question est assez vague, mais en règle générale, vous devriez essayer de réduire la redondance dans votre code. Par conséquent, vous devez placer la déclaration de l'énumération d'un fichier d'en-tête.

InformationsquelleAutor avakar
0

Cela dépend vraiment de si les valeurs sont du même type logique, ou si ils ont juste arriver à avoir les mêmes noms. Serait-il judicieux d'attribuer Un a::variable de Type C::Type? Si elles sont du même type logique, les mettre dans un en-tête qui comprennent à la fois. Pour garder votre temps de construire faible, vous voulez probablement mettre dans son propre fichier d'en-tête, mais de la mettre en colocation à-tête avec d'autres œuvres de trucs si vous voulez garder le nombre de fichiers.

Une autre option est de mettre enum dans une classe de base commune que les deux hériter (cela peut ne pas faire sens dans ce cas, mais il est une autre option).

InformationsquelleAutor Dolphin

Vous devez vous connecter pour publier un commentaire.