以通用方式对所有结构成员求和

Question

I have a lot of of C struct which represent counters. Those structs consist of several members of the same type, let's say uint64_t . In the program I have several instances of the same struct and in some cases I need to sum all those same struct. I don't want to use operator+ for this because in future the structs can change and have more or less members and I don't want to always modify the operator as well.

I thought that I could use a sizeof and create an array of struct's member type from the struct and then sum the array. I would make an union of that struct and an array. This would solve my problem of not wanting to modify the operator when new member is added or removed, but this would work only while the struct contains only members of the same type.

So maybe there is some generic, template method of doing this, but I'm not that good with templates so I ask you C++ gurus for help.

Example of such struct:

struct counter{
    uint64_t a;
    uint64_t b;
    uint64_t c;
    uint64_t d;
    uint64_t e;
};

Answer 1

Not the best way, but one way to achieve the functionality you need is:

/* counter.xh */
COUNTER_MEMBER(uint64_t, a);
COUNTER_MEMBER(uint64_t, b);
COUNTER_MEMBER(uint64_t, c);
COUNTER_MEMBER(uint64_t, d);
COUNTER_MEMBER(uint64_t, e);

Then in some header:

/* counter.h */

struct counter{
#define COUNTER_MEMBER(TYPE,NAME) TYPE NAME;
    #include "counter.xh"
};

Now comes the add function:

/* foo.cpp */
uint64_t add_members(const counter &obj) {
  uint64_t sum = 0LLU;
#define COUNTER_MEMBER(TYPE,NAME) sum += obj.NAME;
#include "counter.xh"
  return sum;  /* I hope there was no overflow */
}

Live example

Answer 2

I think this is not the best solution, however it can be a useful method. If struct Counter have more or less members, I change GetSumOfAll() function only.

struct Counter 
{
    uint64_t a;
    uint64_t b;
    uint64_t c;
    uint64_t d;
    uint64_t e;
};
typedef std::vector< Counter > VecCounter;

uint64_t GetSumOfMember( const VecCounter& vec, uint64_t Counter::*member )
{
    uint64_t sum = 0;

    std::for_each( vec.begin(), vec.end(), [&]( const Counter& counter )
    {
        sum += counter.*member;
    });

    return sum;
}

uint64_t GetSumOfAll( const VecCounter& vec )
{
    uint64_t sumA = GetSumOfMember( vec, &Counter::a );
    uint64_t sumB = GetSumOfMember( vec, &Counter::b );
    uint64_t sumC = GetSumOfMember( vec, &Counter::c );
    uint64_t sumD = GetSumOfMember( vec, &Counter::d );
    uint64_t sumE = GetSumOfMember( vec, &Counter::e );

    return sumA + sumB + sumC + sumD + sumE;
}

int main()
{
    VecCounter v{ { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 } };
    uint64_t sum = GetSumOfAll( v );

    return 0;
}