Find the number of elements in an enumerated type?

[David Mathog]

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

The example below compiles and runs but returns 4 twice (the number of
bytes used to store a value in test) when the needed answer is 5 (the
number of enumerated values in atype).

#include <stdlib.h>
#include <stdio.h>
enum atype {ZERO,ONE,TWO,T HREE,FOUR};
int main(void){
enum atype test;
(void) fprintf(stdout, "1: %d\n",sizeof(te st));
(void) fprintf(stdout, "2: %d\n",sizeof(en um atype));
(void) exit(EXIT_SUCCE SS);
}

One could insert

#define TESTN 5

after the enum statement, and use that, but it still requires the
programmer to count the number of elements, as opposed to having the
computer do it.

Maybe I'm assuming too much. Doesn't the C standard say that the enum
statement, without any "=" within the {}, always assigns the enumerated
values as 0,1,2,3,4? Seems like there should be a way to get the
preprocessor or run time to cough up the number of elements.

I did come up with this method, which will work so long as the special
last element is never displaced from it's position at the end of the
list. It is kind of hideous though:

#include <stdlib.h>
#include <stdio.h>
enum atype {ONE,TWO,THREE, FOUR,FIVE, I_AM_ALWAYS_LAS T};
int main(void){
enum atype test;
test = I_AM_ALWAYS_LAS T ;
(void) fprintf(stdout, "%d\n",test );
(void) exit(EXIT_SUCCE SS);
}
Thanks,

David Mathog

[Ian Collins]

David Mathog wrote:

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

The example below compiles and runs but returns 4 twice (the number of
bytes used to store a value in test) when the needed answer is 5 (the
number of enumerated values in atype).

No.

If you must know (which is probably rare), add a known last element.
Even that only works if the values are contiguous and start form 0.

--
Ian Collins.

[borophyll]

On Sep 29, 8:33 am, David Mathog <mat...@caltech .eduwrote:

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

Not directly, but you could declare enums in the following way, using
some preprocessing magic:

#include <stdlib.h>
#include <stdio.h>
#define ENUM_START(type ) enum type {
#define ENUMCONCAT(type ) I_AM_ALWAYS_LAS T_ ## type
#define ENUM_END(type) ENUMCONCAT(type ) };
#define ENUM_SIZE(type) ENUMCONCAT(type )

ENUM_START(atyp e)
ONE,
TWO,
THREE,
FOUR,
FIVE,
ENUM_END(atype)

int main(void)
{
enum atype atest = ENUM_SIZE(atype );
(void) fprintf(stdout, "%d\n",ates t);
(void) exit(EXIT_SUCCE SS);

}

[*coffee*]

On Sep 29, 2:26 pm, boroph...@gmail .com wrote:

On Sep 29, 8:33 am, David Mathog <mat...@caltech .eduwrote:

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

Not directly, but you could declare enums in the following way, using
some preprocessing magic:

#include <stdlib.h>
#include <stdio.h>
#define ENUM_START(type ) enum type {
#define ENUMCONCAT(type ) I_AM_ALWAYS_LAS T_ ## type
#define ENUM_END(type) ENUMCONCAT(type ) };
#define ENUM_SIZE(type) ENUMCONCAT(type )

ENUM_START(atyp e)
ONE,
TWO,
THREE,
FOUR,
FIVE,
ENUM_END(atype)

int main(void)
{
enum atype atest = ENUM_SIZE(atype );
(void) fprintf(stdout, "%d\n",ates t);
(void) exit(EXIT_SUCCE SS);

Nice. BUT this way we couldn't assign the value in ENUM.
It's difficult to me.

--coffee

[Richard Tobin]

In article <11************ **********@y42g 2000hsy.googleg roups.com>,
<bo*******@gmai l.comwrote:

>#define ENUMCONCAT(type ) I_AM_ALWAYS_LAS T_ ## type
#define ENUM_END(type) ENUMCONCAT(type ) };
#define ENUM_SIZE(type) ENUMCONCAT(type )

I have often used the manual version of this - inserting an extra
item in the enumeration. It has the minor disadvantage that some
compilers (such as gcc) will give a warning about a missing value
in switch statements that cover all the real values.

-- Richard

--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Thad Smith]

David Mathog wrote:

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

The example below compiles and runs but returns 4 twice (the number of
bytes used to store a value in test) when the needed answer is 5 (the
number of enumerated values in atype).

#include <stdlib.h>
#include <stdio.h>
enum atype {ZERO,ONE,TWO,T HREE,FOUR};
int main(void){
enum atype test;
(void) fprintf(stdout, "1: %d\n",sizeof(te st));
(void) fprintf(stdout, "2: %d\n",sizeof(en um atype));
(void) exit(EXIT_SUCCE SS);
}

One could insert

#define TESTN 5

after the enum statement, and use that, but it still requires the
programmer to count the number of elements, as opposed to having the
computer do it.

Maybe I'm assuming too much. Doesn't the C standard say that the enum
statement, without any "=" within the {}, always assigns the enumerated
values as 0,1,2,3,4? Seems like there should be a way to get the
preprocessor or run time to cough up the number of elements.

I did come up with this method, which will work so long as the special
last element is never displaced from it's position at the end of the
list. It is kind of hideous though:

#include <stdlib.h>
#include <stdio.h>
enum atype {ONE,TWO,THREE, FOUR,FIVE, I_AM_ALWAYS_LAS T};
int main(void){
enum atype test;
test = I_AM_ALWAYS_LAS T ;
(void) fprintf(stdout, "%d\n",test );
(void) exit(EXIT_SUCCE SS);
}

I use your method, David:
enum eModulation {
EM_FM, EM_AM, EM_CM, EM_NUM_MODS};
--
Thad

[CBFalconer]

Richard Tobin wrote:

<bo*******@gmai l.comwrote:

>#define ENUMCONCAT(type ) I_AM_ALWAYS_LAS T_ ## type
#define ENUM_END(type) ENUMCONCAT(type ) };
#define ENUM_SIZE(type) ENUMCONCAT(type )

I have often used the manual version of this - inserting an extra
item in the enumeration. It has the minor disadvantage that some
compilers (such as gcc) will give a warning about a missing value
in switch statements that cover all the real values.

So simply write a suitable switch statement:

switch (enumval) {
case ONE: ...
...
case FOUR: ...
default: fputs("Invalid enumval encountered\n", stderr;
}

or whatever error catching mechanism you prefer.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[Richard Tobin]

In article <46************ ***@yahoo.com>,
CBFalconer <cb********@mai neline.netwrote :

>I have often used the manual version of this - inserting an extra
item in the enumeration. It has the minor disadvantage that some
compilers (such as gcc) will give a warning about a missing value
in switch statements that cover all the real values.

>So simply write a suitable switch statement:

>default: fputs("Invalid enumval encountered\n", stderr;

Yes, of course you can do that. But (a) it's annoying to have to do
it in dozens of places, (b) it's putting in code to handle a case that
should never happen, just to shut the compiler up, and (c) it
suppresses the warning when you really have made an error.

-- Richard
--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[CBFalconer]

Richard Tobin wrote:

CBFalconer <cb********@mai neline.netwrote :

>>I have often used the manual version of this - inserting an extra
item in the enumeration. It has the minor disadvantage that some
compilers (such as gcc) will give a warning about a missing value
in switch statements that cover all the real values.

>So simply write a suitable switch statement:

>default: fputs("Invalid enumval encountered\n", stderr;

Yes, of course you can do that. But (a) it's annoying to have to do
it in dozens of places, (b) it's putting in code to handle a case that
should never happen, just to shut the compiler up, and (c) it
suppresses the warning when you really have made an error.

Please do not strip attributions for material you quote.

No, it's not useless. enum objects can hold any value, they are
not limited to the actually specified set. If one gets into your
system you want to know about it soonest. Without the default the
value is just ignored, which may not be a viable resolution.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[borophyll]

On Sep 29, 7:47 pm, *coffee* <coffee....@gma il.comwrote:

On Sep 29, 2:26 pm, boroph...@gmail .com wrote:

On Sep 29, 8:33 am, David Mathog <mat...@caltech .eduwrote:

Is there a standard compliant method to access the number of elements in
an enumerated type in C, either from within the preprocessor or the
running program?

Not directly, but you could declare enums in the following way, using
some preprocessing magic:

#include <stdlib.h>
#include <stdio.h>
#define ENUM_START(type ) enum type {
#define ENUMCONCAT(type ) I_AM_ALWAYS_LAS T_ ## type
#define ENUM_END(type) ENUMCONCAT(type ) };
#define ENUM_SIZE(type) ENUMCONCAT(type )

ENUM_START(atyp e)
ONE,
TWO,
THREE,
FOUR,
FIVE,
ENUM_END(atype)

int main(void)
{
enum atype atest = ENUM_SIZE(atype );
(void) fprintf(stdout, "%d\n",ates t);
(void) exit(EXIT_SUCCE SS);

Nice. BUT this way we couldn't assign the value in ENUM.
It's difficult to me.

--coffee

Sorry, yes I should have stated that you can only use this if the
constants are contiguous and begin with 0, but I figured this would be
clear from Ian's post.

Regards,
B.