R – Can an enum be defined in the same file as a class header that uses it in Objective-C

enumsheader-filesobjective c

If not, and it needs to be included in a separate file (e.g. MyEnums.h) do I need to #import MyEnums.h every time a .m or .h file wants to refer to the type or one of the values?

Here's sample code of MyClass.h:

#import <Foundation/Foundation.h>

// #1 placeholder

@interface MyClass : NSObject {
}

// #2 placeholder

- (void)sampleMethod:(MyEnum)useOfEnum;

// #3 placeholder

@end

Here's the enum I'm trying to define:

typedef enum MyEnum {
    Value1,
    Value2
}

If I try placing my enum definition in #1, I get error: no type or storage class may be specified here before 'interface'.

If I try placing my enum definition in #2, I get error: expected identifier or '(' before 'end'.

If I try placing my enum definition in #3, I get error: expected ')' before 'MyEnum'. Which is complaining about the parameter "useOfEnum" because it's type is not defined yet.

So can this be done? Or what is the best way to do this and limit the amount of #imports required?

Best Answer

It should work in position #1, but I think you need to write it like so:

typedef enum {
    Value1,
    Value2
} MyEnum;

To work properly.

update: I have confirmed this (at least in Xcode 3.2). The syntax shown above compiles without errors.

Related Solutions

C++ Why am I unable to use an enum declared globally outside of the class it was declared in

I'm not sure what issue you are having without seeing your code, but this compiles:

enum OutsideEnum
{
    OE_1,
    OE_2,
};

namespace ns
{
    enum NSEnum
    {
       NE_1,
       NE_2,
    };
}

class Base
{
public:
    enum BaseEnum
    {
        BE_1,
        BE_2,
    };

    void BaseFunc();
};

class Derived
{
public:
    enum DerivedEnum
    {
        DE_1,
        DE_2,
    };

    void DerivedFunc();
};

void Base::BaseFunc()
{
    BaseEnum be = BE_1;
    Derived::DerivedEnum de = Derived::DE_1;
    OutsideEnum oe = OE_1;
    ns::NEEnum ne = ns::NE_1;
}

void Derived::DerivedFunc()
{
    Base::BaseEnum be = Base::BE_1;
    DerivedEnum de = DE_1;
    OutsideEnum oe = OE_1;
    ns::NEEnum ne = ns::NE_1;
}

int main()
{
    Base::BaseEnum be = Base::BE_1;
    Derived::DerivedEnum de = Derived::DE_1;
    OutsideEnum oe = OE_1;
    ns::NEEnum ne = ns::NE_1;
}

Two things to watch for with enums defined inside a class definition:

Make sure it's declared public if you want it publicly available.
When referencing it from anywhere other than the class it's defined in, use the class name to qualify the name of the enum and the values.

EDIT:

Ok, the problem has nothing to do with enums, but rather order of inclusion, when you have a base class and a derived class, only the derived class needs to know about the base class:

Base class header:

#ifndef BASE_H
#define BASE_H

enum BaseEnum
{
};

class Base
{
};
#endif

Derived class header:

#ifndef DERIVED_H
#define DERIVED_H

#include "Base.h"

class Derived
{

   void Func(BaseEnum be);
};
#endif

Objective-c – Why can’t I switch an enum in Objective-C

An enum has literal values (basically named integers), not object pointers. Thus it should be:

@property(nonatomic) Tones tone;

Best Answer

Related Solutions

C++ Why am I unable to use an enum declared globally outside of the class it was declared in

Objective-c – Why can’t I switch an enum in Objective-C

Related Topic