Qu'est-ce qu'un ENUM typedef en Objective-C?

StackOverflow https://stackoverflow.com/questions/707512

  •  22-08-2019
  •  | 
  •  

Question

Je ne pense pas que je comprends fondamentalement ce qu'est un enum est, et quand l'utiliser.

Par exemple: 

typedef enum {
    kCircle,
    kRectangle,
    kOblateSpheroid
} ShapeType;

Qu'est-ce qui est réellement déclarée ici?

Était-ce utile?

La solution

Trois choses sont déclarées ici:. Un type anonyme est recensée déclaré, ShapeType est déclarée typedef pour cette énumération anonyme, et les trois noms kCircle, kRectangle et kOblateSpheroid sont déclarées comme des constantes intégrales

Brisons que vers le bas. Dans le cas le plus simple, une énumération peut être déclarée comme 

enum tagname { ... };

déclare une énumération avec l'étiquette tagname. En C et Objective-C (mais pas C ++), toute référence à cette doivent être précédé par le mot-clé enum. Par exemple: 

enum tagname x;  // declare x of type 'enum tagname'
tagname x;  // ERROR in C/Objective-C, OK in C++

Afin d'éviter d'avoir à utiliser partout le mot-clé enum, un typedef peut être créé: 

enum tagname { ... };
typedef enum tagname tagname;  // declare 'tagname' as a typedef for 'enum tagname'

Cela peut être simplifiée en une seule ligne: 

typedef enum tagname { ... } tagname;  // declare both 'enum tagname' and 'tagname'

Et enfin, si l'on n'a pas besoin d'être en mesure d'utiliser enum tagname avec le mot clé enum, nous pouvons faire la enum anonyme et ne déclarer le nom typedef: 

typedef enum { ... } tagname;

Maintenant, dans ce cas, nous déclarant ShapeType être un nom typedef d'une énumération anonyme. ShapeType est vraiment juste un type intégral, et ne doit être utilisé pour déclarer des variables qui détiennent l'une des valeurs énumérées dans la déclaration (qui est l'un des kCircle, kRectangle et kOblateSpheroid). Vous pouvez assigner une variable ShapeType une autre valeur par coulée, cependant, vous devez donc être prudent lors de la lecture des valeurs ENUM.

Enfin, kCircle, kRectangle et kOblateSpheroid sont déclarées comme des constantes intégrées dans l'espace de noms global. Étant donné qu'aucune des valeurs spécifiques ont été spécifiées, ils sont affectés à des nombres entiers consécutifs commençant par 0, donc kCircle est 0, kRectangle est 1 et 2 est kOblateSpheroid.

Autres conseils

Apple recommande de définir énumérations comme celui-ci depuis Xcode 4.4: 

typedef enum ShapeType : NSUInteger {
    kCircle,
    kRectangle,
    kOblateSpheroid
} ShapeType;

Ils fournissent également une NS_ENUM macro pratique: 

typedef NS_ENUM(NSUInteger, ShapeType) {
    kCircle,
    kRectangle,
    kOblateSpheroid
};

Ces définitions fournissent plus forte vérification de type et une meilleure complétion de code. Je ne pouvais pas trouver une documentation officielle de NS_ENUM, mais vous pouvez regarder la vidéo "Modern Objective-C" de la session WWDC 2012 ici .

Mise à jour: Lien vers la documentation officielle ici .

Un ENUM déclare un ensemble de valeurs ordonnées - le typedef ajoute juste un nom à portée de main à ce sujet. Le 1er élément est 0, etc. 

typedef enum {
Monday=1,
...
} WORKDAYS;

WORKDAYS today = Monday;

Ce qui précède est juste une énumération des balises shapeType.

Un type défini par l'utilisateur qui a les valeurs possibles de kCircle, kRectangle ou kOblateSpheroid. Les valeurs à l'intérieur de l'énumération (kCircle, etc) sont visibles à l'extérieur du enum, cependant. Il est important de garder cela à l'esprit (int i = kCircle; est valide, par exemple).

Mise à jour pour le changement 64 bits: Selon docs de pommes sur les changements 64 bits,

  

Les énumérations sont également typées: Dans le compilateur LLVM, les types énumérés peuvent   définir la taille de l'énumération. Cela signifie que certains dénombrées   types peuvent également avoir une taille qui est plus grand que prévu. le   solution, comme dans tous les autres cas, est de faire aucune hypothèse sur un   la taille du type de données. Au lieu de cela, attribuer des valeurs énumérées à une variable   avec le type de données approprié

Vous devez créer ENUM avec le type comme ci-dessous la syntaxe si vous appuyez 64 bits. 

typedef NS_ENUM(NSUInteger, ShapeType) {
    kCircle,
    kRectangle,
    kOblateSpheroid
};

ou 

typedef enum ShapeType : NSUInteger {
   kCircle,
   kRectangle,
   kOblateSpheroid
} ShapeType;

Dans le cas contraire, il conduira à avertir que Implicit conversion loses integer precision: NSUInteger (aka 'unsigned long') to ShapeType

Mise à jour pour programmation rapide:

rapide, il y a un changement de syntaxe. 

enum ControlButtonID: NSUInteger {
        case kCircle , kRectangle, kOblateSpheroid
    }

Le enum (abréviation de dénombrement) est utilisé pour énumérer un ensemble de valeurs (enquêteurs). Une valeur est une chose abstraite représentée par un symbole (un mot). Par exemple, un ENUM de base pourrait être 

enum { xs,s,m,l,xl,xxl,xxxl,xxxxl };

Ce ENUM est appelé anonyme parce que vous ne disposez pas d'un symbole pour le nommer. Mais il est encore tout à fait correct. Il suffit de l'utiliser comme ceci 

enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize;

Ok. La vie est belle et tout va bien. Mais un jour, vous avez besoin de réutiliser ce ENUM pour définir une nouvelle variable pour stocker myGrandFatherPantSize, vous écrivez: 

enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize;
enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandFatherPantSize;

Mais alors vous avez une erreur compilateur « redéfinition du recenseur ». En fait, le problème est que le compilateur est pas sûr que vous devez d'abord ENUM et vous êtes deuxième décrire la même chose.

Ensuite, si vous souhaitez réutiliser le même ensemble des agents recenseurs (ici xs ... XXXXL) dans plusieurs endroits que vous devez marquer avec un nom unique. La deuxième fois que vous utilisez ce jeu il vous suffit d'utiliser la balise. Mais ne pas oublier que cette balise ne remplace pas le mot enum mais juste l'ensemble des agents recenseurs. Ensuite, prendre soin d'utiliser ENUM comme d'habitude. Comme ceci: 

// Here the first use of my enum
enum sizes { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize; 
// here the second use of my enum. It works now!
enum sizes myGrandFatherPantSize;

vous pouvez l'utiliser dans une définition de paramètre ainsi: 

// Observe that here, I still use the enum
- (void) buyANewDressToMyGrandMother:(enum sizes)theSize;

On pourrait dire que la réécriture ENUM partout est pas pratique et rend le code semble un peu étrange. Tu as raison. Un type réel serait mieux.

Ceci est la dernière étape de notre grande progression au sommet. En ajoutant simplement un typedef Transformons notre ENUM dans un type réel. Oh la dernière chose, typedef est pas autorisé dans votre classe. Définissez ensuite votre type juste au-dessus. Faites-le comme ceci: 

// enum definition
enum sizes { xs,s,m,l,xl,xxl,xxxl,xxxxl };
typedef enum sizes size_type

@interface myClass {
   ...
   size_type myGrandMotherDressSize, myGrandFatherPantSize;
   ...
}

Rappelez-vous que l'étiquette est facultative. Ensuite, puisqu'ici, dans ce cas, nous ne les étiquettent pas les agents recenseurs, mais juste de définir un nouveau type. Ensuite, nous ne pas vraiment plus besoin. 

// enum definition
typedef enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } size_type;

@interface myClass : NSObject {
  ...
  size_type myGrandMotherDressSize, myGrandFatherPantSize;
  ...
}
@end

Si vous développez en Objective-C avec XCode Je vous laisse découvrir quelques macros belles préfixées NS_ENUM. Cela devrait vous aider à définir la bonne énumérations facilement et de plus va aider l'analyseur statique à faire quelques vérifications intéressantes pour vous avant de compiler.

Bon Enum!

typedef est utile pour redéfinir le nom d'un type variable existante. Il fournit la manière courte et significative pour appeler un type de données. par exemple: 

typedef unsigned long int TWOWORDS;

ici, le type unsigned long int est redéfinie pour être des TWOWORDS de type. Ainsi, nous pouvons maintenant déclarer des variables de type unsigned long int en écrivant, 

TWOWORDS var1, var2;

au lieu de 

unsigned long int var1, var2;

typedef enum {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;

vous pouvez l'utiliser comme: - 

 ShapeType shape;

et 

 enum {
    kCircle,
    kRectangle,
    kOblateSpheroid
} 
ShapeType;

vous pouvez l'utiliser comme: - 

enum ShapeType shape;

enum est utilisée pour assigner une valeur à enum éléments qui ne peuvent pas être faites dans struct. Donc, à chaque fois au lieu d'accéder à la variable complète, nous pouvons le faire par la valeur que nous attribuons aux variables ENUM. Par défaut, il commence par 0 cession, mais nous pouvons lui attribuer une valeur et la variable suivante dans ENUM sera attribué une valeur à la valeur précédente +1.

A typedef permet au programmeur de définir un type Objective-C comme un autre. Par exemple,

typedef int compteur; définit le type compteur à équivalent au type int. Cela améliore considérablement la lisibilité du code.

Le Typedef est un mot-clé en C et C ++. Il est utilisé pour créer de nouveaux noms pour les types de données de base (char, int, float, double, struct et ENUM) . 

typedef enum {
    kCircle,
    kRectangle,
    kOblateSpheroid
} ShapeType;

Ici, il crée le type de données dénombrée shapeType et nous pouvons écrire de nouveaux noms pour le type enum shapeType comme indiqué ci-dessous 

ShapeType shape1; 
ShapeType shape2; 
ShapeType shape3;

Vous pouvez utiliser dans le format ci-dessous, la valeur par défaut brut à partir de 0, donc

  • kCircle est 0,
  • kRectangle est 1,
  • kOblateSpheroid est 2.

Vous pouvez affecter votre propre valeur de départ spécifique. 

typedef enum : NSUInteger {
    kCircle, // for your value; kCircle = 5, ...
    kRectangle,
    kOblateSpheroid
} ShapeType;

ShapeType circleShape = kCircle;
NSLog(@"%lu", (unsigned long) circleShape); // prints: 0

ENUM peut réduire de nombreux types de « erreurs » et rendre le code plus facile à gérer 

#define STATE_GOOD 0
#define STATE_BAD 1
#define STATE_OTHER 2
int STATE = STATE_OTHER

La définition n'a pas de contraintes. Il est tout simplement une substitution. Il ne peut pas limiter toutes les conditions de l'État. Lorsque l'état est affecté à 5, le programme sera mauvais, parce qu'il n'y a pas d'état correspondant. Mais le compilateur ne va pas avertir ÉTAT = 5

Il est donc préférable d'utiliser comme ceci 

typedef enum SampleState {
    SampleStateGood  = 0,
    SampleStateBad,
    SampleStateOther
} SampleState;

SampleState state = SampleStateGood;
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top