Convertit objective-c typedef en équivalent chaîne
En supposant que j'ai un typedef déclaré dans mon fichier .h en tant que tel:
typedef enum {
JSON,
XML,
Atom,
RSS
} FormatType;
Je voudrais construire une fonction qui convertit la valeur numérique de la typedef en une chaîne. Par exemple, si le message [self toString:JSON] a été envoyé; il retournerait 'JSON'.
La fonction ressemblerait à ceci:
-(NSString *) toString:(FormatType)formatType {
//need help here
return [];
}
Incidemment, si j'essaie cette syntaxe
[self toString:FormatType.JSON];
pour passer la valeur typedef à la méthode, j'obtiens une erreur. Qu'est-ce que je rate?
C'est vraiment une question C, pas spécifique à Objective-C (qui est un sur-ensemble du langage C). Les énumérations en C sont représentées sous forme d'entiers. Vous devez donc écrire une fonction qui retourne une chaîne avec une valeur enum. Il y a plusieurs façons de le faire. Un tableau de chaînes tel que la valeur enum puisse être utilisé comme index dans le tableau ou dans une structure de carte (par exemple, un NSDictionary) mappant une valeur enum sur un travail en chaîne, mais je trouve que ces approches ne sont pas aussi claire qu'une fonction qui rend la conversion explicite (et l'approche tableau, bien que le chemin classique C soit dangereux si vos valeurs enum ne sont pas contiguës à 0). Quelque chose comme ça marcherait:
- (NSString*)formatTypeToString:(FormatType)formatType {
NSString *result = nil;
switch(formatType) {
case JSON:
result = @"JSON";
break;
case XML:
result = @"XML";
break;
case Atom:
result = @"Atom";
break;
case RSS:
result = @"RSS";
break;
default:
[NSException raise:NSGenericException format:@"Unexpected FormatType."];
}
return result;
}
Votre question connexe sur la syntaxe correcte pour une valeur enum est que vous utilisez uniquement la valeur (par exemple, JSON), pas le FormatType.JSON sytax. FormatType est un type et les valeurs enum (par exemple JSON, XML, etc.) sont des valeurs que vous pouvez affecter à ce type.
Vous ne pouvez pas le faire facilement. En C et Objective-C, les énumérations ne sont en réalité que des constantes entières glorifiées. Vous devrez générer vous-même une table de noms (ou avec un abus du préprocesseur). Par exemple:
// In a header file
typedef enum FormatType {
JSON,
XML,
Atom,
RSS
} FormatType;
extern NSString * const FormatType_toString[];
// In a source file
// initialize arrays with explicit indices to make sure
// the string match the enums properly
NSString * const FormatType_toString[] = {
[JSON] = @"JSON",
[XML] = @"XML",
[Atom] = @"Atom",
[RSS] = @"RSS"
};
...
// To convert enum to string:
NSString *str = FormatType_toString[theEnumValue];
Le danger de cette approche est que si vous modifiez jamais l'énum, vous devez vous rappeler de changer le tableau de noms. Vous pouvez résoudre ce problème avec certains abus de préprocesseur, mais c'est délicat et laid.
Notez également que cela suppose que vous avez une constante enum valide. Si vous avez une valeur entière provenant d'une source non fiable, vous devez également vérifier que votre constante est valide, par exemple. en incluant une valeur "past max" dans votre enum ou en vérifiant si elle est inférieure à la longueur du tableau, sizeof(FormatType_toString) / sizeof(FormatType_toString[0]).
Ma solution:
edit: J'ai même ajouté une meilleure solution à la fin, en utilisant Modern Obj-C
1.
Placez les noms comme clés dans un tableau.
Assurez-vous que les index sont les énumérations appropriées, et dans le bon ordre (sinon exception).
remarque: noms est une propriété synthétisée sous la forme * * _names *;
la compilation du code n'a pas été vérifiée, mais j'ai utilisé la même technique dans mon application.
typedef enum {
JSON,
XML,
Atom,
RSS
} FormatType;
+ (NSArray *)names
{
static NSMutableArray * _names = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_names = [NSMutableArray arrayWithCapacity:4];
[_names insertObject:@"JSON" atIndex:JSON];
[_names insertObject:@"XML" atIndex:XML];
[_names insertObject:@"Atom" atIndex:Atom];
[_names insertObject:@"RSS" atIndex:RSS];
});
return _names;
}
+ (NSString *)nameForType:(FormatType)type
{
return [[self names] objectAtIndex:type];
}
//
2.
En utilisant Modern Obj-C, vous pouvez utiliser un dictionnaire pour relier les descriptions aux clés de l’énumération.
L'ordre importe pe.
typedef NS_ENUM(NSUInteger, UserType) {
UserTypeParent = 0,
UserTypeStudent = 1,
UserTypeTutor = 2,
UserTypeUnknown = NSUIntegerMax
};
@property (nonatomic) UserType type;
+ (NSDictionary *)typeDisplayNames
{
return @{@(UserTypeParent) : @"Parent",
@(UserTypeStudent) : @"Student",
@(UserTypeTutor) : @"Tutor",
@(UserTypeUnknown) : @"Unknown"};
}
- (NSString *)typeDisplayName
{
return [[self class] typeDisplayNames][@(self.type)];
}
Utilisation (dans une méthode d'instance de classe):
NSLog(@"%@", [self typeDisplayName]);
En combinant la réponse @AdamRosenfield, le commentaire @Christoph et un autre truc pour gérer les énormes C, je suggère:
// In a header file
typedef enum {
JSON = 0, // explicitly indicate starting index
XML,
Atom,
RSS,
FormatTypeCount, // keep track of the enum size automatically
} FormatType;
extern NSString *const FormatTypeName[FormatTypeCount];
// In a source file
NSString *const FormatTypeName[FormatTypeCount] = {
[JSON] = @"JSON",
[XML] = @"XML",
[Atom] = @"Atom",
[RSS] = @"RSS",
};
// Usage
NSLog(@"%@", FormatTypeName[XML]);
Dans le pire des cas - par exemple si vous modifiez l'énumération mais oubliez de modifier le tableau de noms - la valeur retournée sera nil pour cette clé.
définir typedef enum dans l'en-tête de la classe:
typedef enum {
IngredientType_text = 0,
IngredientType_audio = 1,
IngredientType_video = 2,
IngredientType_image = 3
} IngredientType;
écris une méthode comme celle-ci en classe:
+ (NSString*)typeStringForType:(IngredientType)_type {
NSString *key = [NSString stringWithFormat:@"IngredientType_%i", _type];
return NSLocalizedString(key, nil);
}
avoir les chaînes à l'intérieur Localizable.strings fichier:
/* IngredientType_text */
"IngredientType_0" = "Text";
/* IngredientType_audio */
"IngredientType_1" = "Audio";
/* IngredientType_video */
"IngredientType_2" = "Video";
/* IngredientType_image */
"IngredientType_3" = "Image";
J'utiliserais le jeton # string du compilateur (avec des macros pour le rendre plus compact):
#define ENUM_START \
NSString* ret; \
switch(value) {
#define ENUM_CASE(evalue) \
case evalue: \
ret = @#evalue; \
break;
#define ENUM_END \
} \
return ret;
NSString*
_CvtCBCentralManagerStateToString(CBCentralManagerState value)
{
ENUM_START
ENUM_CASE(CBCentralManagerStateUnknown)
ENUM_CASE(CBCentralManagerStateResetting)
ENUM_CASE(CBCentralManagerStateUnsupported)
ENUM_CASE(CBCentralManagerStateUnauthorized)
ENUM_CASE(CBCentralManagerStatePoweredOff)
ENUM_CASE(CBCentralManagerStatePoweredOn)
ENUM_END
}
J'aime le #define manière de faire ceci:
// Placez ceci dans votre fichier .h, en dehors du bloc @interface
typedef enum {
JPG,
PNG,
GIF,
PVR
} kImageType;
#define kImageTypeArray @"JPEG", @"PNG", @"GIF", @"PowerVR", nil
// Place this in the .m file, inside the @implementation block
// A method to convert an enum to string
-(NSString*) imageTypeEnumToString:(kImageType)enumVal
{
NSArray *imageTypeArray = [[NSArray alloc] initWithObjects:kImageTypeArray];
return [imageTypeArray objectAtIndex:enumVal];
}
source (la source n'est plus disponible)
J'ai fait une sorte de mélange de toutes les solutions trouvées sur cette page pour créer le mien, c'est une sorte d'extension d'énum orientée objet ou quelque chose.
En fait, si vous avez besoin de plus que de constantes (c'est-à-dire des entiers), vous avez probablement besoin d'un objet de modèle (nous parlons tous de MVC, n'est-ce pas?)
Posez-vous simplement la question avant d’utiliser ceci, n’ai-je pas raison, n’avez-vous pas besoin d’un objet modèle réel, initialisé à partir d’un service Web, d’un plist, d’une base de données SQLite ou de CoreData?
Quoi qu'il en soit, voici le code (MPI est pour "My Project Initials", tout le monde utilise ceci ou son nom, semble-t-il):
MyWonderfulType.h:
typedef NS_ENUM(NSUInteger, MPIMyWonderfulType) {
MPIMyWonderfulTypeOne = 1,
MPIMyWonderfulTypeTwo = 2,
MPIMyWonderfulTypeGreen = 3,
MPIMyWonderfulTypeYellow = 4,
MPIMyWonderfulTypePumpkin = 5
};
#import <Foundation/Foundation.h>
@interface MyWonderfulType : NSObject
+ (NSString *)displayNameForWonderfulType:(MPIMyWonderfulType)wonderfulType;
+ (NSString *)urlForWonderfulType:(MPIMyWonderfulType)wonderfulType;
@end
Et MyWonderfulType.m:
#import "MyWonderfulType.h"
@implementation MyWonderfulType
+ (NSDictionary *)myWonderfulTypeTitles
{
return @{
@(MPIMyWonderfulTypeOne) : @"One",
@(MPIMyWonderfulTypeTwo) : @"Two",
@(MPIMyWonderfulTypeGreen) : @"Green",
@(MPIMyWonderfulTypeYellow) : @"Yellow",
@(MPIMyWonderfulTypePumpkin) : @"Pumpkin"
};
}
+ (NSDictionary *)myWonderfulTypeURLs
{
return @{
@(MPIMyWonderfulTypeOne) : @"http://www.theone.com",
@(MPIMyWonderfulTypeTwo) : @"http://www.thetwo.com",
@(MPIMyWonderfulTypeGreen) : @"http://www.thegreen.com",
@(MPIMyWonderfulTypeYellow) : @"http://www.theyellow.com",
@(MPIMyWonderfulTypePumpkin) : @"http://www.thepumpkin.com"
};
}
+ (NSString *)displayNameForWonderfulType:(MPIMyWonderfulType)wonderfulType {
return [MPIMyWonderfulType myWonderfulTypeTitles][@(wonderfulType)];
}
+ (NSString *)urlForWonderfulType:(MPIMyWonderfulType)wonderfulType {
return [MPIMyWonderfulType myWonderfulTypeURLs][@(wonderfulType)];
}
@end
Une autre solution:
typedef enum BollettinoMavRavTypes {
AMZCartServiceOperationCreate,
AMZCartServiceOperationAdd,
AMZCartServiceOperationGet,
AMZCartServiceOperationModify
} AMZCartServiceOperation;
#define AMZCartServiceOperationValue(operation) [[[NSArray alloc] initWithObjects: @"CartCreate", @"CartAdd", @"CartGet", @"CartModify", nil] objectAtIndex: operation];
Dans votre méthode, vous pouvez utiliser:
NSString *operationCheck = AMZCartServiceOperationValue(operation);
Amélioration de la réponse @ yar1vn en supprimant la dépendance à la chaîne:
#define VariableName(arg) (@""#arg)
typedef NS_ENUM(NSUInteger, UserType) {
UserTypeParent = 0,
UserTypeStudent = 1,
UserTypeTutor = 2,
UserTypeUnknown = NSUIntegerMax
};
@property (nonatomic) UserType type;
+ (NSDictionary *)typeDisplayNames
{
return @{@(UserTypeParent) : VariableName(UserTypeParent),
@(UserTypeStudent) : VariableName(UserTypeStudent),
@(UserTypeTutor) : VariableName(UserTypeTutor),
@(UserTypeUnknown) : VariableName(UserTypeUnknown)};
}
- (NSString *)typeDisplayName
{
return [[self class] typeDisplayNames][@(self.type)];
}
Ainsi, lorsque vous modifierez le nom de l'entrée enum, la chaîne correspondante sera modifiée. Utile dans le cas où vous n'allez pas montrer cette chaîne à l'utilisateur.
J'utilise une variante de la réponse de Barry Walk, qui, par ordre d'importance:
- Permet au compilateur de vérifier les clauses de cas manquantes (il ne le peut pas si vous avez une clause par défaut).
- Utilise un nom typique Objective-C (plutôt qu'un nom Java comme nom).
- Lève une exception spécifique.
- Est plus courte.
PAR EXEMPLE:
- (NSString*)describeFormatType:(FormatType)formatType {
switch(formatType) {
case JSON:
return @"JSON";
case XML:
return @"XML";
case Atom:
return @"Atom";
case RSS:
return @"RSS";
}
[NSException raise:NSInvalidArgumentException format:@"The given format type number, %ld, is not known.", formatType];
return nil; // Keep the compiler happy - does not understand above line never returns!
}
J'avais un grand type énuméré que je voulais convertir en NSDictionary. J'ai fini par utiliser sed à partir d'un terminal OSX en tant que:
$ sed -E 's/^[[:space:]]{1,}([[:alnum:]]{1,}).*$/ @(\1) : @"\1",/g' ObservationType.h
qui peut être lu comme: 'capture le premier mot sur la ligne et affiche le résultat @ (Word): @ "Word",'
Cette expression rationnelle convertit l'énumération en un fichier d'en-tête nommé 'ObservationType.h' qui contient:
typedef enum : int {
ObservationTypePulse = 1,
ObservationTypeRespRate = 2,
ObservationTypeTemperature = 3,
.
.
}
dans quelque chose comme:
@(ObservationTypePulse) : @"ObservationTypePulse",
@(ObservationTypeRespRate) : @"ObservationTypeRespRate",
@(ObservationTypeTemperature) : @"ObservationTypeTemperature",
.
.
qui peut ensuite être encapsulé dans une méthode utilisant la syntaxe moderne objective-c @{ } (comme expliqué par @ yar1vn ci-dessus) pour créer une recherche NSDictionary:
-(NSDictionary *)observationDictionary
{
static NSDictionary *observationDictionary;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
observationDictionary = [[NSDictionary alloc] initWithDictionary:@{
@(ObservationTypePulse) : @"ObservationTypePulse",
@(ObservationTypeRespRate) : @"ObservationTypeRespRate",
.
.
}];
});
return observationDictionary;
}
Le dispatch_once chaudière-plaque est juste pour s'assurer que la variable statique est initialisée de manière sécurisée.
Remarque: j'ai trouvé l'expression sed regex sur OSX étrange - lorsque j'ai essayé d'utiliser + pour correspondre à "un ou plusieurs", cela n'a pas fonctionné et a dû recourir à {1,} en remplacement
J'ai combiné plusieurs approches ici. J'aime l'idée du préprocesseur et de la liste indexée.
Il n'y a pas d'allocation dynamique supplémentaire et, du fait de l'inline, le compilateur pourrait peut-être optimiser la recherche.
typedef NS_ENUM(NSUInteger, FormatType) { FormatTypeJSON = 0, FormatTypeXML, FormatTypeAtom, FormatTypeRSS, FormatTypeCount };
NS_INLINE NSString *FormatTypeToString(FormatType t) {
if (t >= FormatTypeCount)
return nil;
#define FormatTypeMapping(value) [value] = @#value
NSString *table[FormatTypeCount] = {FormatTypeMapping(FormatTypeJSON),
FormatTypeMapping(FormatTypeXML),
FormatTypeMapping(FormatTypeAtom),
FormatTypeMapping(FormatTypeRSS)};
#undef FormatTypeMapping
return table[t];
}
@pixel a ajouté la réponse la plus brillante ici: https://stackoverflow.com/a/24255387/1364257 S'il vous plait, upvote lui!
Il utilise la macro X soignée des années 1960. (J'ai légèrement modifié son code pour l'ObjC moderne)
#define X(a, b, c) a b,
enum ZZObjectType {
XXOBJECTTYPE_TABLE
};
typedef NSUInteger TPObjectType;
#undef X
#define XXOBJECTTYPE_TABLE \
X(ZZObjectTypeZero, = 0, @"ZZObjectTypeZero") \
X(ZZObjectTypeOne, , @"ZZObjectTypeOne") \
X(ZZObjectTypeTwo, , @"ZZObjectTypeTwo") \
X(ZZObjectTypeThree, , @"ZZObjectTypeThree")
+ (NSString*)nameForObjectType:(ZZObjectType)objectType {
#define X(a, b, c) @(a):c,
NSDictionary *dict = @{XXOBJECTTYPE_TABLE};
#undef X
return dict[objectType];
}
C'est ça. Propre et soigné. Merci à @pixel! https://stackoverflow.com/users/21804/pixel
Étant donné une définition enum comme:
typedef NS_ENUM(NSInteger, AssetIdentifier) {
Isabella,
William,
Olivia
};
Nous pouvons définir une macro pour convertir une valeur enum en chaîne correspondante, comme indiqué ci-dessous.
#define AssetIdentifier(asset) \
^(AssetIdentifier identifier) { \
switch (identifier) { \
case asset: \
default: \
return @#asset; \
} \
}(asset)
L'instruction switch utilisée dans le bloc sert à la vérification de type et à la prise en charge de l'auto-complétion dans Xcode.
Tout d’abord, en ce qui concerne FormatType.JSON: JSON n’est pas membre de FormatType, c’est une valeur possible du type. FormatType n'est même pas un type composite, c'est un scalaire.
Deuxièmement, la seule façon de procéder consiste à créer une table de mappage. La manière la plus courante de faire cela en Objective-C est de créer une série de constantes faisant référence à vos "symboles", afin que vous ayez NSString *FormatTypeJSON = @"JSON" etc.
ce qui suit fournit une solution telle que l'ajout d'une nouvelle énumération ne nécessite qu'une édition sur une ligne, travail similaire à l'ajout d'une seule ligne dans une liste enum {}.
//------------------------------------------------------------------------------
// enum to string example
#define FOR_EACH_GENDER(tbd) \
tbd(GENDER_MALE) \
tbd(GENDER_FEMALE) \
tbd(GENDER_INTERSEX) \
#define ONE_GENDER_ENUM(name) name,
enum
{
FOR_EACH_GENDER(ONE_GENDER_ENUM)
MAX_GENDER
};
#define ONE_GENDER(name) #name,
static const char *enumGENDER_TO_STRING[] =
{
FOR_EACH_GENDER(ONE_GENDER)
};
// access string name with enumGENDER_TO_STRING[value]
// or, to be safe converting from a untrustworthy caller
static const char *enumGenderToString(unsigned int value)
{
if (value < MAX_GENDER)
{
return enumGENDER_TO_STRING[value];
}
return NULL;
}
static void printAllGenders(void)
{
for (int ii = 0; ii < MAX_GENDER; ii++)
{
printf("%d) gender %s\n", ii, enumGENDER_TO_STRING[ii]);
}
}
//------------------------------------------------------------------------------
// you can assign an arbitrary value and/or information to each enum,
#define FOR_EACH_PERSON(tbd) \
tbd(2, PERSON_FRED, "Fred", "Weasley", GENDER_MALE, 12) \
tbd(4, PERSON_GEORGE, "George", "Weasley", GENDER_MALE, 12) \
tbd(6, PERSON_HARRY, "Harry", "Potter", GENDER_MALE, 10) \
tbd(8, PERSON_HERMIONE, "Hermione", "Granger", GENDER_FEMALE, 10) \
#define ONE_PERSON_ENUM(value, ename, first, last, gender, age) ename = value,
enum
{
FOR_EACH_PERSON(ONE_PERSON_ENUM)
};
typedef struct PersonInfoRec
{
int value;
const char *ename;
const char *first;
const char *last;
int gender;
int age;
} PersonInfo;
#define ONE_PERSON_INFO(value, ename, first, last, gender, age) \
{ ename, #ename, first, last, gender, age },
static const PersonInfo personInfo[] =
{
FOR_EACH_PERSON(ONE_PERSON_INFO)
{ 0, NULL, NULL, NULL, 0, 0 }
};
// note: if the enum values are not sequential, you need another way to lookup
// the information besides personInfo[ENUM_NAME]
static void printAllPersons(void)
{
for (int ii = 0; ; ii++)
{
const PersonInfo *pPI = &personInfo[ii];
if (!pPI->ename)
{
break;
}
printf("%d) enum %-15s %8s %-8s %13s %2d\n",
pPI->value, pPI->ename, pPI->first, pPI->last,
enumGenderToString(pPI->gender), pPI->age);
}
}
Chaque réponse ici dit fondamentalement la même chose, crée une énumération régulière puis utilise un getter personnalisé pour passer d'une chaîne à une autre.
J'utilise une solution beaucoup plus simple, plus rapide, plus courte et plus propre, avec des macros!
#define kNames_allNames ((NSArray <NSString *> *)@[@"Alice", @"Bob", @"Eve"])
#define kNames_alice ((NSString *)kNames_allNames[0])
#define kNames_bob ((NSString *)kNames_allNames[1])
#define kNames_eve ((NSString *)kNames_allNames[2])
Ensuite, vous pouvez simplement commencer à taper kNam... Et la saisie semi-automatique affichera les listes que vous désirez!
De plus, si vous souhaitez gérer simultanément la logique de tous les noms, vous pouvez simplement énumérer rapidement le tableau littéral dans l'ordre, comme suit:
for (NSString *kName in kNames_allNames) {}
Enfin, le casting de NSString dans les macros assure un comportement similaire à typedef!
Prendre plaisir!
Beaucoup de réponses toutes assez bonnes.
Si vous recherchez une solution générique, Objective C qui utilise des macros ...
La fonctionnalité clé est qu'il utilise l'énumération comme un index dans un tableau statique de constantes NSString. le tableau lui-même est encapsulé dans une fonction pour le rendre plus semblable à la suite de fonctions NSStringFromXXX qui prévalent dans les API Apple.
vous aurez besoin de #import "NSStringFromEnum.h" trouvé ici http://Pastebin.com/u83RR3Vk
[EDIT] a également besoin de #import "SW+Variadic.h" Trouvé ici http://Pastebin.com/UEqTzYLf
Exemple 1: définissez complètement un NEW enum typedef, avec des convertisseurs de chaîne.
dans monfichier.h
#import "NSStringFromEnum.h"
#define define_Dispatch_chain_cmd(enum)\
enum(chain_done,=0)\
enum(chain_entry)\
enum(chain_bg)\
enum(chain_mt)\
enum(chain_alt)\
enum(chain_for_c)\
enum(chain_while)\
enum(chain_continue_for)\
enum(chain_continue_while)\
enum(chain_break_for)\
enum(chain_break_while)\
enum(chain_previous)\
enum(chain_if)\
enum(chain_else)\
interface_NSString_Enum_DefinitionAndConverters(Dispatch_chain_cmd)
dans myfile.m:
#import "myfile.h"
implementation_NSString_Enum_Converters(Dispatch_chain_cmd)
utiliser :
NSString *NSStringFromEnumDispatch_chain_cmd(enum Dispatch_chain_cmd value);
NSStringFromEnumDispatch_chain_cmd(chain_for_c) renvoie @"chain_for_c"
enum Dispatch_chain_cmd enumDispatch_chain_cmdFromNSString(NSString *value);
enumDispatch_chain_cmdFromNSString(@"chain_previous") renvoie chain_previous
Exemple 2: fournir des routines de conversion pour une énumération existante illustre également l'utilisation d'une chaîne de paramètres et le renommage du nom de type utilisé dans les fonctions.
dans monfichier.h
#import "NSStringFromEnum.h"
#define CAEdgeAntialiasingMask_SETTINGS_PARAMS CAEdgeAntialiasingMask,mask,EdgeMask,edgeMask
interface_NSString_Enum_Converters(CAEdgeAntialiasingMask_SETTINGS_PARAMS)
dans myfile.m:
// we can put this in the .m file as we are not defining a typedef, just the strings.
#define define_CAEdgeAntialiasingMask(enum)\
enum(kCALayerLeftEdge)\
enum(kCALayerRightEdge)\
enum(kCALayerBottomEdge)\
enum(kCALayerTopEdge)
implementation_NSString_Enum_Converters(CAEdgeAntialiasingMask_SETTINGS_PARAMS)
Ici fonctionne -> https://github.com/ndpiparava/ObjcEnumString
//1st Approach
#define enumString(arg) (@""#arg)
//2nd Approach
+(NSString *)secondApproach_convertEnumToString:(StudentProgressReport)status {
char *str = calloc(sizeof(kgood)+1, sizeof(char));
int goodsASInteger = NSSwapInt((unsigned int)kgood);
memcpy(str, (const void*)&goodsASInteger, sizeof(goodsASInteger));
NSLog(@"%s", str);
NSString *enumString = [NSString stringWithUTF8String:str];
free(str);
return enumString;
}
//Third Approcah to enum to string
NSString *const kNitin = @"Nitin";
NSString *const kSara = @"Sara";
typedef NS_ENUM(NSUInteger, Name) {
NameNitin,
NameSara,
};
+ (NSString *)thirdApproach_convertEnumToString :(Name)weekday {
__strong NSString **pointer = (NSString **)&kNitin;
pointer +=weekday;
return *pointer;
}