Tutorial :Enum in C++ like Enum in Ada?


At one point I had looked at implementing a class/template in C++ that would support an Enum that would behave like it does in Ada. It has been some time since I thought about this problem and I was wondering if anyone has ever solved this problem?


My apologies, I should clarify what functionality I thought were useful in the Ada implementation of the Enum. Given the enumeration

type fruit is (apple, banana, cherry, peach, grape);  

We know that fruit is one of the listed fruits: apple, banana, cherry, peach, grape. Nothing really different there from C++.

What is very useful are the following pieces of functionality that you get with every enum in Ada without any additional work:

  • printing out an enumerated value generates the string version
  • you can increment the enumerated variable
  • you can decrement the enumerated variable

I hope this defines the problem a bit more.

Notes added from comments:

Useful features of Ada enumerations

  • The first value in the enumeration is fruit'first which gives apple.
  • The last value in the enumeration is fruit'last which gives grape.
  • The increment operation is fruit'succ(apple) which gives banana.
  • The decrement operation is fruit'pred(cherry) which also gives banana.
  • The conversion from enumeration to integer is fruit'pos(cherry) which returns 2 because Ada uses 0-based enumerations.
  • The conversion from integer to enumeration is fruit'val(2) which returns cherry.
  • The conversion from enumeration to string is fruit'Image(apple) which returns the (upper-case) string "APPLE".
  • The conversion from string to enumeration is fruit'Value("apple") which returns the value apple.

See also related SO questions:


Okay, let's leave C++ aside for a moment. C++ is just a superset of C (which means everything that can be done in C can be done in C++ as well). So let's concentrate on plain-C (because that's a language I know well). C has enumerations:

enum fruit { apple, banana, cherry, peach, grape };  

This is perfectly legal C and the values are contiguous, and apple has the value zero and banana has the value apple + 1. You can create enumerations with holes, but only if you explicitly make holes like this

enum  fruit { apple = 0, banana, cherry = 20, peach, grape };  

While apple is 0 and banana is 1, cherry is 20, thus peach is 21 and grape is 22 and everything between 1 and 20 is undefined. Usually you don't want holes. You can do the following:

enum fruit { apple = 0, banana, cherry, peach, grape };  enum fruit myFruit = banana;  myFruit++;  // myFruit is now cherry  printf("My fruit is cherry? %s\n", myFruit == cherry ? "YES" : "NO");  

This will print YES. You can also do the following:

enum fruit { apple = 0, banana, cherry = 20, peach, grape };  enum fruit myFruit = banana;  myFruit++;  // myFruit is now cherry  printf("My fruit is cherry? %s\n", myFruit == cherry ? "YES" : "NO");  

This will print NO, and the value of myFruit is not the same as any of the enumeration constants.

BTW, to avoid that you must say "enum fruit myFruit", you can avoid the enum with a typedef. Just use "typedef enum fruit fruit;" on an own line. Now you can say "fruit myFruit" without enum in front. It is often done directly when the enum is defined:

typedef enum fruit { apple = 0, banana, cherry, peach, grape } fruit;    fruit myFruit;  

Disadvantage is that you don't know anymore that fruit is an enum, it might be an object, a structure or anything else. I usually avoid these type of typedefs, I rather write enum in front if an enum and struct in front if a struct (I will just use them here because it looks nicer).

Getting the string value is not possible. At runtime an enumeration is just a number. That means, it's not possible if you don't know what kind of enumeration that is (as 0 might be apple, but it might also be a different thing of a different enumeration set). However, if you know it is a fruit, then it's easy to write a function that will do it for you. The preprocessor is your friend :-)

typedef enum fruit {      apple = 0,      banana,      cherry,      peach,      grape  } fruit;    #define STR_CASE(x) case x: return #x  const char * enum_fruit_to_string(fruit f) {      switch (f) {          STR_CASE(apple); STR_CASE(banana); STR_CASE(cherry);          STR_CASE(peach); STR_CASE(grape);      }      return NULL;  }  #undef STR_CASE    static void testCall(fruit f) {      // I have no idea what fruit will be passed to me, but I know it is      // a fruit and I want to print the name at runtime      printf("I got called with fruit %s\n", enum_fruit_to_string(f));  }    int main(int argc, char ** argv) {      printf("%s\n", enum_fruit_to_string(banana));      fruit myFruit = cherry;      myFruit++; // myFruit is now peach      printf("%s\n", enum_fruit_to_string(myFruit));      // I can also pass an enumeration to a function      testCall(grape);      return 0;  }  


banana  peach  I got called with fruit grape  

This is exactly what you wanted or am I totally on the wrong track here?


One of my colleagues has implemented a tool to generate classes that do most (if not all) of what you want:


The current implementation is in Lisp, but do not hold that against him :-)


There isn't an easy way to do that in C++, not least because the enumeration constants are not required to be unique or contiguous. The conversion from value to string is also non-trivial; the solutions I know of involve C/C++ Preprocessor hackery - and that is a pejorative use of the term hackery.

I'm tempted to say "No"; I'm not certain that's correct, but it most certainly is non-trivial.


you might take a look at the java enum (http://madbean.com/2004/mb2004-3/) and this idea: http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern


If you're interested in enumgen, I made a simple demo with your example. As already mentioned, I implemented it using common lisp, so the input file you write is lispy, but I tried really hard to make the syntax reasonable.

Here it is:

$ cat Fruit.enum  (def-enum "Fruit" (("apple")                     ("banana")                     ("cherry")                     ("peach")                     ("grape")                     ("INVALID_")))    $ enumgen Fruit.enum  Using clisp  ;; Loading file /tmp/enumgen/enumgen.lisp ...  ;; Loaded file /tmp/enumgen/enumgen.lisp  loading def file:  ;; Loading file /tmp/enumgen/enumgen.def ...  ;; Loaded file /tmp/enumgen/enumgen.def  generating output:    Fruit.cpp    Fruit.ipp    Fruit.hpp  DONE  

To view the generated code, visit this url: http://code.google.com/p/enumgen/source/browse/#svn/trunk/demo

While it's pretty feature-rich as it is, there are a lot of things that can be tweaked as well, by setting variables in the input file or by specifying attributes of the enumerators.

For example, by default it represents the string names using std::string, but it can use char const * or any user-defined string class given a little effort.

You can have multiple names map to the same enum value, but must pick one to be the "primary" such that mapping the value to a string will result in this name (as opposed to the others.)

You can explicitly provide values to the enums, and they do not need to be unique. (Duplicates are implicit aliases for the previous enum with the same value.)

Further, you can iterate over all the unique values, and for each value over all its aliases, which is useful if you want to generate script-language "wrappers" for these, like we do using ruby.

If you're interested in using this and have questions, feel free to contact me via email. (cuzdav at gmail).

Hope this helps. (There isn't a lot of documentation aside from the test suite and demo code, and the source if you care about that.)



I wrote an enum_iterator that does this, together with a ENUM macro using Boost.Preprocessor:

#include <iostream>  #include "enum.hpp"    ENUM(FooEnum,     (N)    (A = 1)    (B = 2)    (C = 4)    (D = 8));    int main() {    litb::enum_iterator< FooEnum, litb::SparseRange<FooEnum> > i = N, end;    while(i != end) {      std::cout << i.to_string() << ": " << *i << std::endl;      ++i;    }  }  

It declares the enum as plain old enum, so you may still use it for "normal" purposes. The iterator can be used for other normal enums too that have sequential values, that's why it has a second template parameter which defaults to litb::ConsequtiveRange<>. It conforms to the bidirectional iterator requirements.

The silly code can be downloaded from here


This article shows you how to generate the string version of an enumerated value, although it requires that you write the code to do so yourself. It also provides a preprocessor macro to very easily permit incrementing and decrementing enumerated variables, as long as your enum is continuous.

This library provides more flexible incrementing and decrementing.

The enum_rev4.6.zip library in the Boost Vault provides easy string conversions. It looks like it supports incrementing and decrementing using iterators (which is probably less convenient, but it works). It's basically undocumented, although the libs/test directory contains some good example code.


It's unreleased software but it seems BOOST_ENUM from Frank Laub could fit the bill. The part I like about it is that you can define an enum within the scope of a class which most of the Macro based enums usually don't let you do. It is located in the Boost Vault at: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=enum_rev4.6.zip&directory=& It hasn't seen any development since 2006 so I don't know how well it compiles with the new Boost releases. Look under libs/test for an example of usage. There is also Boost smart_enum (not released either). It does the iterator part of your question but not the output to a string. http://cryp.to/smart-enum/

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »