Sum alle Strukturelemente in generischer Weise

Question

Ich habe eine Menge von C-Struktur, die Zähler darstellen. Diese Strukturen bestehen aus mehreren Mitgliedern des gleichen Typs, sagen wir uint64_t. Im Programm habe ich mehrere Instanzen der gleichen Struktur und in einigen Fällen muss ich alle diese gleiche Struktur summieren. Ich möchte operator+ dafür nicht verwenden, weil die Strukturen in Zukunft ändern können und mehr oder weniger Mitglieder haben und ich den Operator auch nicht immer ändern möchte.

Ich dachte, dass ich eine sizeof verwenden und ein Array des Strukturtyps der Struktur aus der Struktur erstellen und dann das Array summieren könnte. Ich würde eine Vereinigung dieser Struktur und eines Arrays machen. Dies würde mein Problem lösen, den Operator nicht ändern zu wollen, wenn ein neues Mitglied hinzugefügt oder entfernt wird, aber dies würde nur funktionieren, solange die Struktur nur Mitglieder des gleichen Typs enthält.

Also vielleicht gibt es einige generische, Template-Methode, dies zu tun, aber ich bin nicht so gut mit Vorlagen, so frage ich Sie C++ Gurus um Hilfe.

Beispiel einer solchen Struktur:

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

Answer 1

nicht der beste Weg, sondern eine Möglichkeit, die Funktionalität, die Sie brauchen, um zu erreichen ist:

/* 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); 

Dann in einigen Header:

/* counter.h */ 

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

Jetzt kommt die Add-Funktion:

/* 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

Ich denke, das nicht die beste Lösung ist, aber es kann eine nützliche Methode sein. Wenn struct Counter mehr oder weniger Mitglieder haben, ändere ich GetSumOfAll() Funktion nur.

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; 
}