Les énumérations à l'intérieur d'une classe C++

Je suis en train d'essayer d'utiliser une classe qui a un type enum déclaré à l'intérieur de la classe comme ceci:

class x {
public:
    x(int);
    x( const x &);
    virtual ~x();
    x & operator=(const x &);
    virtual double operator()() const;

    typedef enum  {
        LINEAR = 0,      ///Perform linear interpolation on the table
        DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
    } XEnumType; 
};

J'ai besoin de déclarer une instance de cette classe et d'initialiser le type enum. Je viens de C# et normalement voir les énumérations, a déclaré à l'EXTÉRIEUR de la classe, pas à l'INTÉRIEUR, comme c'est ici. Comment initialiser le type enum. Par exemple, je veux faire quelque chose comme ceci:

x myX(10);   
myX.XEnumType = Linear;

Évidemment, cela ne fonctionne pas. Comment puis-je faire?

OriginalL'auteur Blade3 | 2011-05-06

c++enums

9

Vous devez d'abord déclarer une variable du type XEnumType au sein de votre classe
Vous pouvez alors accéder au réel des valeurs d'une énumération en utilisant le nom de la classe pour la portée: x::LINEAR ou x::DIPARABOLIC
```
class x{
 //Your other stuff

XEnumType myEnum;
};

int main(void)
{
    x myNewClass();
    x.myEnum = x::LINEAR;
}
```
+1, me battre pour elle. Aussi, vous devriez vous débarrasser de cette typedef mot-clé face à l'enum (il suffit d'utiliser enum XEnumType {...}) - vous êtes en C++ maintenant.
Ne fait pas de mal à l'avoir, mais vous avez raison, le typedef est inutile en c++

OriginalL'auteur Dan F
6

Première: Ne pas utiliser typedef. Au lieu de cela, mettez le nom de l'énumération dans sa tête
```
enum XEnumType {
    LINEAR = 0,      ///Perform linear interpolation on the table
    DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
};
```
En un mot, de faire comme vous l'avez fait va se comporter surtout le même, mais dans les arcanes coin des cas sera différent. La syntaxe que vous avez utilisé un comportement très différent de la syntaxe que j'ai utilisé ci-dessus uniquement en C.

Deuxième: Que juste définit un type. Mais vous souhaitez définir un objet de cette énumération. Faire:
```
XEnumType e;
```
En résumé:
```
class x {
    /* ... stays the same ... */

    enum XEnumType {
        LINEAR = 0,      ///Perform linear interpolation on the table
        DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
    }; 

    XEnumType e;
};

void someFunction() {
    x myX(10);
    myX.e = x::LINEAR;
}
```
"N'utilisez pas de typedef." Pourriez-vous expliquer pourquoi?
En C, la déclaration d'une struct MyStruct {}; nécessaire, vous pouvez toujours vous référer au type struct MyStruct. C'est pourquoi les gens ont fait un typedef struct {} MyStruct;, pour qu'ils puissent utiliser juste MyStruct que le type. C++ n'ont pas cette exigence; vous pouvez déclarer struct MyStruct {}; et toujours utiliser MyStruct que le type. L'application de typedef dans ce contexte, c'est redondant.

OriginalL'auteur Johannes Schaub - litb

enum XEnumType {
    LINEAR, DIPARABOLIC
};

class x {    
    public:    
      x(int);    
      x( const x &);    
      virtual ~x();    
      x & operator=(const x &);    
      virtual double operator()() const;    
      XEnumType my_enum;
};

Utilisation:

x myX(10);
myX.my_enum = LINEAR;

OriginalL'auteur mcorley

Vous avez déclaré un nouveau type : XEnumType. Vous devez créer un champ de ce type à l'intérieur de x de la classe.
.
Par exemple:

class x {

public:

x(int);

x( const x &);

virtual ~x();

x & operator=(const x &);

virtual double operator()() const;

typedef enum  {
    LINEAR = 0,      ///Perform linear interpolation on the table
    DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
} XEnumType; 
public:
XenumType type;
};

Ensuite, vous pouvez accéder à cette façon:

x foo(10);
foo.type = LINEAR;

OriginalL'auteur Heisenbug

la ligne

typedef enum  {
    LINEAR = 0,      ///Perform linear interpolation on the table
    DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
} XEnumType;

définit un type appelé XEnumType, effectivement, c'est redondant de toute façon - préférez quelque chose comme:

enum XEnumType
{
  LINEAR = 0,      ///Perform linear interpolation on the table
  DIPARABOLIC = 1  ///Perform parabolic interpolation on the table
};

Maintenant, vous devez définir un membre de ce type dans votre classe

XEnumType _eType;

Dans votre constructeur, vous pouvez initialiser à ce que

x::x(int ) : _eType(x::LINEAR) {}

OriginalL'auteur Nim

0

Permettez-moi d'abord d'assumer certaines conditions préalables:
- Classe x est à partir d'une bibliothèque tierce et ne peut donc pas être changé.
- Classe x définit des constantes entières avec l'aide d'un enum.
- Classe x est censé être initialisé avec une des constantes de LINEAR ou DIPARABOLIC.
Votre problème est que ces valeurs constantes sont déclarées dans la classe x. Donc, pour initialiser une instance de x vous devez spécifier le champ d'application:

Au lieu de
```
x myX(10);   
myX.XEnumType = Linear;
```
essayer
```
x myX(x::LINEAR);
```
En spécifiant x:: vous fournir le champ d'application de la constante.

OriginalL'auteur Martin Hennings

Vous devez vous connecter pour publier un commentaire.