Objective-C Language
enums

Syntaxis

• typedef NS_ENUM (type, naam) {...} - type is het type opsomming en naam is de naam van het opsomming. waarden zijn in "...". Dit creëert een basisoverzicht en een type dat daarbij hoort; programma's zoals Xcode gaan ervan uit dat een variabele met het enum-type een van de enum-waarden heeft

Een opsomming definiëren

Enums worden gedefinieerd door de volgende syntaxis.

typedef NS_ENUM(NSUInteger, MyEnum) {
    MyEnumValueA,
    MyEnumValueB,
    MyEnumValueC,
};

U kunt ook uw eigen ruwe waarden instellen op de opsommingstypen.

typedef NS_ENUM(NSUInteger, MyEnum) {
    MyEnumValueA = 0,
    MyEnumValueB = 5,
    MyEnumValueC = 10,
};

U kunt ook de eerste waarde opgeven en alle volgende gebruiken deze in stappen:

typedef NS_ENUM(NSUInteger, MyEnum) {
    MyEnumValueA = 0,
    MyEnumValueB,
    MyEnumValueC,
};

Variabelen van dit enum kunnen worden gemaakt door MyEnum enumVar = MyEnumValueA .

typedef enum-verklaring in doelstelling-C

Een opsomming verklaart een reeks geordende waarden - het typedef voegt hier gewoon een handige naam aan toe. Het 1e element is 0 etc.

 typedef enum {
        Monday=1,
        Tuesday,
        Wednesday

    } WORKDAYS;

    WORKDAYS today = Monday;//value 1

C ++ std :: vector omzetten naar een Objective-C-array

Veel C ++ - bibliotheken gebruiken enums en retourneren / ontvangen gegevens met vectoren die enums bevatten. Omdat C-enums geen Objective-C-objecten zijn, kunnen Objective-C-verzamelingen niet rechtstreeks met C-enums worden gebruikt. In het onderstaande voorbeeld wordt dit opgelost door een combinatie van een NSArray en generics en een wrapper-object voor de array te gebruiken. Op deze manier kan de verzameling expliciet zijn over het gegevenstype en hoeft u zich geen zorgen te maken over mogelijke geheugenlekken met C-arrays Objective-C-objecten worden gebruikt.

Hier is het C enum & Objective-C equivalent object:

typedef enum 
{  
  Error0 = 0,
  Error1 = 1,
  Error2 = 2
} MyError;

@interface ErrorEnumObj : NSObject

@property (nonatomic) int intValue;

+ (instancetype) objWithEnum:(MyError) myError;
- (MyError) getEnumValue;

@end 

@implementation ErrorEnumObj

+ (instancetype) objWithEnum:(MyError) error
{
    ErrorEnumObj * obj = [ErrorEnumObj new];
    obj.intValue = (int)error;
    return obj;
}

- (MyError) getEnumValue
{
    return (MyError)self.intValue;
}

@end

En hier is een mogelijk gebruik ervan in Objective-C ++ (de resulterende NSArray kan alleen in Objective-C-bestanden worden gebruikt omdat er geen C ++ wordt gebruikt).

class ListenerImpl : public Listener
{
public:
    ListenerImpl(Listener* listener) : _listener(listener) {}
    void onError(std::vector<MyError> errors) override
    {
        NSMutableArray<ErrorEnumObj *> * array = [NSMutableArray<ErrorEnumObj *> new]; 
        for (auto&& myError : errors)
        {
            [array addObject:[ErrorEnumObj objWithEnum:myError]];
        }
        [_listener onError:array];
    }

private:
    __weak Listener* _listener;
}

Als dit soort oplossing op meerdere enums moet worden gebruikt, kan de EnumObj (aangifte en implementatie) worden gemaakt met behulp van een macro (om een sjabloonachtige oplossing te maken).