Zoeken…


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).



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow