Is this legal ? (non-contiguous values for enums)

[Bart Simpson]

typedef enum {
ACCESS_DENIED = 1,
ACCESS_READ_ONLY = 2,
ACCESS_READ_WRITE = 4
}AccessTypeEnum ;

Is this legal? - can I have 'gaps' in the enumeration integer values as
above ?

[Vladimir S. Oka]

Bart Simpson wrote:

typedef enum {
ACCESS_DENIED = 1,
ACCESS_READ_ONLY = 2,
ACCESS_READ_WRITE = 4
}AccessTypeEnum ;

Is this legal? - can I have 'gaps' in the enumeration integer values as
above ?

Yes.

If you don't provide any values, they start at 0. Between any two
values you provide, the ones without explicit values are incremented by
1 starting from the last one specified.

--
BR, Vladimir

[Keith Thompson]

"Vladimir S. Oka" <no****@btopenworld.com> writes:

Bart Simpson wrote:

typedef enum {
ACCESS_DENIED = 1,
ACCESS_READ_ONLY = 2,
ACCESS_READ_WRITE = 4
}AccessTypeEnum ;

Is this legal? - can I have 'gaps' in the enumeration integer values as
above ?

Yes.

If you don't provide any values, they start at 0. Between any two
values you provide, the ones without explicit values are incremented by
1 starting from the last one specified.

You can even have repeated values:

enum foo {
foo_first = 0,
zero = 0,
one = 1,
two = 2,
foo_last = 2
};

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Vladimir S. Oka]

Keith Thompson wrote:

"Vladimir S. Oka" <no****@btopenworld.com> writes:

Bart Simpson wrote:

typedef enum {
ACCESS_DENIED = 1,
ACCESS_READ_ONLY = 2,
ACCESS_READ_WRITE = 4
}AccessTypeEnum ;

Is this legal? - can I have 'gaps' in the enumeration integer values as
above ?

Yes.

If you don't provide any values, they start at 0. Between any two
values you provide, the ones without explicit values are incremented by
1 starting from the last one specified.

You can even have repeated values:

enum foo {
foo_first = 0,
zero = 0,
one = 1,
two = 2,
foo_last = 2
};

I didn't know that. Do you have an example of how it can be useful?

--
BR, Vladimir

[Sandeep]

Vladimir S. Oka wrote:

You can even have repeated values:

enum foo {
foo_first = 0,
zero = 0,
one = 1,
two = 2,
foo_last = 2
};

I didn't know that. Do you have an example of how it can be useful?

A possible Usage :

enum err_codes
{
err_foo = -1,
err_bar = -1,
err_success = 0
};

For clarity , you might want to provide named constants with same value
but different names. The above enum can be used to return the error
code using different name.

[Michael Mair]

Vladimir S. Oka schrieb:

Keith Thompson wrote:

"Vladimir S. Oka" <no****@btopenworld.com> writes:

Bart Simpson wrote:

typedef enum {
ACCESS_DENIED = 1,
ACCESS_READ_ONLY = 2,
ACCESS_READ_WRITE = 4
}AccessTypeEnum ;

Is this legal? - can I have 'gaps' in the enumeration integer values as
above ?

Yes.

If you don't provide any values, they start at 0. Between any two
values you provide, the ones without explicit values are incremented by
1 starting from the last one specified.

You can even have repeated values:

enum foo {
foo_first = 0,
zero = 0,
one = 1,
two = 2,
foo_last = 2
};

I didn't know that. Do you have an example of how it can be useful?

If you have logical subranges in the enumeration constants,
then you often find the equivalent of the above, i.e.

enum foo {
EFooInvalid,

EFooErrStart,
EFooErrBar = EFooErrStart,
....
EFooErrBaz,
EFooErrEnd = EFooErrBaz,

EFooWarnStart,
EFooWarnQux = EFooWarnStart,
....

EFooSuccessStart,
EFooOK = EFooSuccessStart,
EFooFullSuccess,
EFooSuccessEnd = EFooFullSuccess,

EFooMaxReturn = ESuccessEnd,

EFooNumReturnCodes
};

int isFooWarningReturn (enum foo retval)
{
return (EFooWarnStart <= retval)
&& (retval <= EFooWarnEnd);
}

I usually use separate values for the "Ends".
This can make sense for bitranges, too.
E.g.
enum FooOffsets {
EFoStartWobble = 0,
EFoIsRoundWobble = 0,
...
EFoWobbleTypeBit3,
EFoEndWobble,

EFoStartWibble = EFoEndWobble,
EFoIsSquareWibble = EFoStartWibble,
....
EFoEndWibble,
....
};

#define CONCAT(a, b) a##b
#define FOO_MASK(WKind) ((1 << CONCAT(EFoEnd, WKind)) \
- (1 << CONCAT(EFoEnd, WKind)))

These are obviously made-up but should give an impression
of what you can abuse this for :-)

Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Kenneth Brody]

"Vladimir S. Oka" wrote:

Keith Thompson wrote:

"Vladimir S. Oka" <no****@btopenworld.com> writes:

Bart Simpson wrote:
> typedef enum {
> ACCESS_DENIED = 1,
> ACCESS_READ_ONLY = 2,
> ACCESS_READ_WRITE = 4
> }AccessTypeEnum ;
>
> Is this legal? - can I have 'gaps' in the enumeration integer values as
> above ?

Yes.

[...] You can even have repeated values:

enum foo {
foo_first = 0,
zero = 0,
one = 1,
two = 2,
foo_last = 2
};

I didn't know that. Do you have an example of how it can be useful?

enum item_list {
item_lowest = 0,
item_foo = 0,
item_bar = 1,
item_foobar = 2,
item_highest = 2
};

You could then, for example, check a list with a for loop going from
"item_lowest" to "item_highest", and not have to worry about adding
additional items in the future.
Question: can an enum entry be based on another entry of the same enum?
For example:

enum item_list {
item_lowest,
item_foo = item_lowest,
item_bar,
item_foobar,
item_highest = item_foobar
};

(This "works" on my system, but we all know how reliable "it works on
my system" is for generalizations.)

--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer.h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Ben Pfaff]

Kenneth Brody <ke******@spamcop.net> writes:

Question: can an enum entry be based on another entry of the same enum?

Yes (as long as dependents follow dependencies).
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Michael Mair]

Kenneth Brody schrieb:

Question: can an enum entry be based on another entry of the same enum?
For example:

enum item_list {
item_lowest,
item_foo = item_lowest,
item_bar,
item_foobar,
item_highest = item_foobar
};

(This "works" on my system, but we all know how reliable "it works on
my system" is for generalizations.)

Yep. An enumeration constant is "visible" as soon as it is declared.

Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.