Redundant macro usage in initializer lists

Question

After I were able to successfully reduce code duplication with this I want to further reduce my code duplication with totally different problem

#include <iostream>
#include <array>

#define A1
#define B2
#define C3
#define D4
#define E5


enum Enum {
#ifdef A1
  one,
#endif
#ifdef B2
  two,
#endif
#ifdef C3
  three,
#endif
#ifdef D4
  four,
#endif
#ifdef E5
  five,
#endif
  end
};

const char* map(Enum e)
{
  switch(e)
  {
    #ifdef A1
    case one  : return "one";
    #endif
    #ifdef B2
    case two: return "two";
    #endif
    #ifdef C3
    case three : return "three";
    #endif
    #ifdef D4
    case four: return "four";
    #endif
    #ifdef E5
    case five: return "five";
    #endif
    case end: return "end";
  }
}

int main()
{
  std::array<const char*, Enum::end + 1> arr{{
    #ifdef A1
      "a",
    #endif
    #ifdef B2
      "b",
    #endif
    #ifdef C3
      "c",
    #endif
    #ifdef D4
      "d",
    #endif
    #ifdef E5
      "e",
    #endif
      "z"
  }};
  int e = 0;
  for (const auto& str : arr)
  {
    std::cout << str << " map " << map(Enum(e)) << std::endl;
    e++;
  }
  return 0;
}

Please note the function map doesn't really exists in my code and was implemented only for this example. In the code above I have two array and their values initialized with initialization list. The problem I want to address is the need to have #ifdef and #endif twice. Instead, I want to have some thing like

#ifdef A1
#define A1_PAIR one, "a",
#else
#define A1_PAIR
#endif
#ifdef B2
#define B2_PAIR two, "b",
#else
#define B2_PAIR
#endif
#ifdef C3
#define C3_PAIR three, "c",
#else
#define C3_PAIR
#endif
#ifdef D4
#define D4_PAIR four, "d",
#else
#define D4_PAIR
#endif
#ifdef E5
#define E5_PAIR five, "e",
#else
#define E5_PAIR
#endif

#define MACRO(index) \
    A1_PAIR \
    B2_PAIR \
    C3_PAIR \
    D4_PAIR \
    E5_PAIR \
    end, "z"

enum Enum{ MACRO(1) };
std::array<const char*, Enum::end 1> arr2{{ MACRO(2) }};

Obviously, this code doesn't work but can I write something in this spirit?

Unfortunately no, I plan to move to c++14 and even c++17 in the future but currently I need to work with c++11 — e271p314, Dec 11 '17 at 12:32
What would be the difference between `MACRO(1)` and `MACRO(2)`? `index` is never used — user7860670, Dec 11 '17 at 12:37
are you really saving more duplicate code than you have to write duplicates of `#ifdef` / `#endif` ? — 463035818_is_not_an_ai, Dec 11 '17 at 12:40
@VTT `index` is not used because I don't know how to write this macro, I just know how I want to use it (similar/equivalent usage without `index` is also acceptable). @tobi303 indeed, code duplication is not the only concern, maintaining the mapping between `arr1` and `arr2` is also a big problem I would like address with this code — e271p314, Dec 11 '17 at 12:54

score 1 · Answer 1 · answered Dec 11 '17 at 13:10

1

You might use pair/tuple to group data together:

std::array<std::pair<const char*, const char*>, NUM + 1> arr{{
#ifdef A1
    {"1", "a"},
#endif
#ifdef B2
    {"2", "b"},
#endif
#ifdef C3
    {"3", "c"},
#endif
#ifdef D4
    {"4", "d"},
#endif
#ifdef E5
    {"5", "e"},
#endif
    {"26", "z"}
}};
for (const auto& p : arr) {
    std::cout << p.first << std::endl;
}
for (const auto& str : arr) {
    std::cout << p.second << std::endl;
}
std::cout << "ok" << std::endl;

answered Dec 11 '17 at 13:10

Jarod42

203,559
14
181
302

Yes you are right, but the real code has a macro that that takes an unknown amount of arguments and an array (that uses this marco to know its size). I can't use an array of pairs because I have to completely different types – e271p314 Dec 11 '17 at 13:26

score 0 · Accepted Answer · answered Dec 11 '17 at 13:11

0

Create one array:

using arr_type=char const[];
#define ARRAY_SOURCE = arr_type{ "1", "a", "2", "b", /* etc */ }

use #ifdef to define indexes.

// elements.inc:
#ifdef A
ARRAY_SOURCE[0+OFFSET],
#endif
// etc

then

std::array<const char*, NUM + 1> arr1{{
#define OFFSET 0
#include "elements.inc"
#undef OFFSET
}};
std::array<const char*, NUM + 1> arr2{{
#define OFFSET 1
#include "elements.inc"
#undef OFFSET
}};

answered Dec 11 '17 at 13:11

Yakk - Adam Nevraumont

262,606
27
330
524

I like this direction, but two things I would like to avoid the need to have `elements.inc`, I would like to have all declaration in the same header file, and the need to bind "a" and "1" to index 0 (as in your example of `elements.inc`) – e271p314 Dec 11 '17 at 13:30
Also, I still want to use `A1`, `B2` macros – e271p314 Dec 16 '17 at 09:24
Nevertheless you inspired me, then using this answer I got to the solution https://stackoverflow.com/questions/47868671/get-subsets-of-macro-values-using-offset#47868897 – e271p314 Dec 18 '17 at 13:09
@e271p314 Consider using code generation instead of BOOST_PP; the virtue of being "a pure CPP compile" is questionable when you are abusing the preprocessor that hard. – Yakk - Adam Nevraumont Dec 18 '17 at 14:29

Redundant macro usage in initializer lists

2 Answers2

Linked