Elegant way of accessing union members of a structure

Question

Is there a way to reverse #define instruction?

In the following example

#define ZERO 0
#define ONE 1
#define TWO 2
#define THREE 3

is it possible to retrieve TWO from the integer value 2?

This example comes from a C code but I can use some C++ code if needed. My goal is to be able to factorize some spurious switch-case loops of this form :

switch(num)
{
   case ZERO:
      return std::to_string(foo.V_ZERO);
   case ONE:
      return std::to_string(foo.V_ONE);
   case TWO:
      return std::to_string(foo.V_TWO);
   case THREE:
      return std::to_string(foo.V_THREE);
}

where foo is an instance of a structure like this:

struct Foo
{
   union Val
   { 
      int V_ZERO;
      int V_ONE;
      double V_TWO; // nonsense: just to say that types are not the same
      int V_THREE;
   };
};

My constraints are the following:

1. I can't remove the functionality provided by #define, i.e. I can write something equivalent, e.g. an enumeration, but I can't lose the map between ZERO and 0, ONE and 1 etc;
2. the existing code is written in C and I can't rewrite it in C++. However, I can write some supplementary C++ code.

I have some ideas to simplify the code but I wonder if there is a very known elegant way of doing this, especially by means of some templates or preprocessor directives.

EDIT: usage of std::to_string added to say that I am not interested in knowing how to convert or handle multiple types from a union.

Answer 1

If you want to automate some of the process, one option would be to use xmacros. They are hacky, but depending on your code size might make maintenance (as in, adding new entries) easier, at the expense of the rage of your fellow co-workers:

Define the xmacro list:

#define XLIST(xmacro) \
   xmacro(ZERO, 0) \
   xmacro(ONE, 1) \
   xmacro(TWO, 2) \
   xmacro(THREE, 3) \

And then use it whenever you want to iterate through all items:

// create an enum containing all items
#define xmacro(name, value) name,
enum Item
{
    XLIST(xmacro)
};
#undef xmacro

// get the number of items
#define xmacro(name, value) +1
const int NumberOfItems = 0 XLIST(xmacro);
#undef xmacro

// enum -> value
int itemToValue(enum Item item)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return value;
        XLIST(xmacro)
#undef xmacro
    }

    return -1;
}

// get enum name
const char * getItemName(enum Item item)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return #name;
        XLIST(xmacro)
#undef xmacro
    }

    return NULL;
}

This will get preprocessed into something like:

enum Item
{
    ZERO,
    ONE, 
    TWO, 
    THREE,
};

const int NumberOfItems = 0 +1 +1 +1 +1; // == 4

int itemToValue(enum Item item)
{
    switch (item)
    {
        case ZERO: return 0; 
        case ONE: return 1; 
        case TWO: return 2; 
        case THREE: return 3;   
    }

    return -1;
}

const char * getItemName(enum Item item)
{
    switch (item)
    {
        case ZERO: return "ZERO"; 
        case ONE: return "ONE"; 
        case TWO: return "TWO"; 
        case THREE: return "THREE";

    }

    return NULL;
}

You can create just about any mapping you'd like from this, i.e. for your struct you would use something similar to what @Jean-François wrote:

// get struct value by item type
double getValueByName(enum Item item, struct Foo values)
{
    switch (item)
    {
        // create a mapping from enum to x
#define xmacro(name, value) case name: return values.V_##name;
        XLIST(xmacro)
#undef xmacro
    }

    return -1;
}

Answer 2

No, that's not possible.

Preprocessor #defines are textually replaced by their definitions by the preprocessing phase. The actual compiler never sees the symbols. What do you feel that TWO is, at run-time? It's already been replaced by the integer literal 2 everywhere, so there's no change.

const int two_define = TWO;
const int two_literal = 2;

will both put the integer value 2 in the respective variables, there's no magic smell that somehow differentiates the TWO from 2. The compiler will see const int two_define = 2; since the preprocessor symbol will be gone.

Also: what is the actual return type of the function, given that you're returning both ints and doubles? That would imply that it's double.

Answer 3

In a general case you have to resort to something like "X macros", as proposed in another answer. But this is the last resort when everything else has failed. You'll have to go there if the numbers are completely arbitrary.

However, in this specific case the numbers are adjacent and starting from zero. That calls for enum combined with a look-up table. The standard way to implement it is like this:

#include <stdio.h>

typedef enum
{
  ZERO,
  ONE,
  TWO,
  THREE,
  SUPPORTED_NUMBERS
} number_t;

const char* STR_NUMBER [] =
{
  "ZERO",
  "ONE",
  "TWO",
  "THREE",
};

_Static_assert((sizeof STR_NUMBER / sizeof *STR_NUMBER) == SUPPORTED_NUMBERS,
               "Error: enum does not correspond to look-up table.");

int main (void)
{
  for(number_t i=0; i<SUPPORTED_NUMBERS; i++)
  {
    printf("%d %s\n", i, STR_NUMBER[i]);
  }
}

Answer 4

For those 2 questions:

Is there a way to reverse #define instruction?

is it possible to retrieve TWO from the integer value 2?

Maybe array of mapping structures is suitable for you:

#define ZERO 0
#define ONE 1
#define TWO 2
#define THREE 3

typedef struct
{
    int number;
    const char *name;
} name_map_t;


#define MAP_NAME_STR(id) { id, #id },


static const name_map_t name_map_table[] =
{
    MAP_NAME_STR( ZERO  )
    MAP_NAME_STR( ONE   )
    MAP_NAME_STR( TWO   )
    MAP_NAME_STR( THREE )
};

Then just loop name_map_table array to find wanted counterpart.

Answer 5

I identify your problem, and I'll show yo what I do when I face this kind of Enumeration pattern:

Let's say I have an enumeration of values, which I want to print, to switch, to represent array indices, etc.

first of all I write an include file that will support all kinds of uses I'm going to do of this enum type:

enum(INITIAL_STATE, 0, "This is the initial state")
enum(FLAG_READ, 1, "We have read the flag symbol")
...

then i use different macro definitions to expand this dataset of registers, as follows:

struct enum MyEnum {
#define enum(val,ix, string) val,
#include "myenumdef.i"
#undef enum
};

/* then, later in the same file ... */

char *MyEnumStrings[] = {
#define enum(val,ix, string) string,
#include "myenumdef.i"
#undef enum
};

/* .... */

char *MyEnumNames[] = {
#define enum(val, ix, string) #val, /* the string equivalent of enum names */
#include "myenumdef.i"
#undef enum
};

/* and more complex forms... like */

struct myEnumDesc {
    int   e_val;
    int   e_ix;
    char *e_name;
    char *e_desc;
} enum_table[] = {
#define enum(val,ix,string) val, ix, #val, string,
#include "myenumdef.i"
#undef enum
}; /* enum_table */


/* ... even, when I want to switch on them */
    switch(val) {
#define enum(val,ix,string) case VAL_##val: return string"("#val"="#ix")";
#include "myenumdef.i"
#undef enum
    default: return "invalid val";
    } /* switch */

Just prepare an example with the above, and run it through the C preprocessor, to see how the final C code looks like.

And you can do this as many times I need (even in a single file), I only need to change how the macro enum (in this case, you can have even several macro names to define and use them to construct more complex data dependencies) before including the data file. In case you want to add a constant to the enum, you have only to add it to the .i file, encoded as it appears above, and everything will adapt for the change.

you asked for C-only solution, so I give the more aproximate way I know about how to deal with the different definitions for the same set of items.