C++ macro function or dynamic member name

Question

I have the following struct:

struct myHandler
{
  bool test1;
  bool test2;
  ...
  bool test400;
};

Which has about 400 test values. So currently I have the following function:

static inline void DoSomething(myHandler& hdler, int test, bool passed)
{
  #define SETTEST(a,b,c) case b: a.test##b=c;

  switch (test)
  {
    SETTEST(hdler, 1, passed)
    SETTEST(hdler, 2, passed)
    ...
    SETTEST(hdler, 400, passed)
  }

  #undef SETTEST
};

I am obviously trying to get rid of repetitive code as there are a lot of tests. So I have tried the following two options: Option1:

static inline void DoSomething(myHandler& hdler, int test, bool passed)
{
  #define SETTEST(a,b,index,c) if(index==b) a.test##b=c;

  for(i = 1; i <= 400; ++i)
  {
    SETTEST(hdler, test, i, passed)
  }

  #undef SETTEST
};

Obviously this does not compile, as when it concatenates using ## it takes "test" literally. Don't know how or if I can get around this.

Option2:

template<typename FUNCTION>
inline void setTest(FUNCTION f) {
  for (int i = 1; i <= 5; ++i) {
    f(i);
  }
};

static inline void DoSomething(myHandler& hdler, int test, bool passed
{
  setTest([&](const int testNum) { 
    if(test == testNum) {
      hdler.test##testNum = passed;
    }
  });
};

Obviously option2 won't compile either, I don't know how to access the member of the struct using some dynamic form. Now, there are some changes to the actual struct that will solve this easily, however modifying the struct is not an option as it gets formed through some other methods, and this is just example code to portray my problem. I just want to know if there is a way to do what I am trying to achieve (without modifying the struct) that I have missed. Really I am leaning towards option 2, however from what I have read there is no way of concatenating dynamically to access a member. Any help is appreciated.

Answer 1

Why not to do this:

struct myHandler {
   bool test[400] = {};
};

PS. And no, the thing you are trying to do is impossible, because you're trying to mix code preprocessing or compile time and execution time. Some may think about recursive templates, but again, you can't do that either for same reason as you can't do that in template.

Best (and worst) effort you can do it to access struct through char*. Any code reviewer would make a wine goblet from your skull for doing that either. Specifically, this is an anti-pattern (usually):

myHandler s {};
unsigned char* p = reinterpret_cast<unsigned char*>(&s);

int index_value = 200;
int n = 0;
// sets index_value-th element to true.
std::generate(p, p+sizeof(s), [&n,=](){ return (++n)==index_value; })
//                    your "array" starts with 1^^^        

It would be a little fancy if bool isn't equal to char.. or if you need a larger type. generate does increment by 1 only. But you can iterate through array by any way possible.

Answer 2

Boost PP shines again.

#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>

#define SET_TEST(z, n, data) \
    case n: hdler.BOOST_PP_CAT(test, n) = passed; break;
//             Note : was the break missing here? ^^^^^^

switch (test)
{
    BOOST_PP_REPEAT_FROM_TO(1, 400, SET_TEST, ~)
}

#undef SET_TEST

Oh -- you'll need a custom build of Boost.PP so it goes up to 400 instead of the default 256 :)

No seriously... please use an array if you can.

Answer 3

There is no way you can write a few lines of code to access the individual members of your struct.

Macros and templates is to resolved at compile time so you can't write a macro-like function that access members at runtime.

So, if you are really stuck with a struct like that, you have to write a wrapper that can hide the rather ugly nature of the struct. It will still take a lot of lines to write the wrapper but once that is done, the other parts of your code will be more simple.

It could look like:

#include <iostream>
#include <array>
using namespace std;

struct myHandler
{
  bool test1;
  bool test2;
  // ..
  bool test400;
};

struct myHandlerWrapper
{
    myHandlerWrapper(myHandler& mh)
    {
        h[0] = &mh.test1;
        h[1] = &mh.test2;
            // .. 
        h[399] = &mh.test400;
    }

    bool& operator[](size_t i)  // This gives the easy access to members using simple indexing
    {
        return *h[i];
    }

    private:
    array<bool*, 400> h;
};

int main() {
    myHandler mh;
    myHandlerWrapper handler(mh);

    handler[0] = false;  // Access members using simple indexing via the wrapper
    handler[1] = true;

    cout << (handler[0] ? "true" : "false") << endl;
    cout << (handler[1] ? "true" : "false") << endl;

    return 0;
}

Answer 4

I don't think there's an easy solution to your problem here, but you could try the top answer here.

It discusses if it's possible to iterate through a struct's members (which isn't possible in C++), and offers an alternative using Boost, if that's an option for you.