Generics types in a queue - c++

Question

I get a queue of events which must contain a class with generic variables. In order to do that I tried to use the tuples. I used variadic templates to generate my tuples but I can't put them in my queue because of their types which aren't the same. Could you give me some advise about how to do this?
#include <type_traits>
#include <iostream>
#include <vector>
#include <iostream>
#include <tuple>
#include <utility>
#include <queue>
class Logs
{
public:
Logs() {}
template <class T, class... Values>
void write(T data, Values&&... values) {
auto save = std::tuple_cat(_t, std::make_tuple(data)); // I would like to save the return in a variable class
write(values...);
}
void write() {
// the end
// _queue.push(save);
}
std::tuple& getTuple() { return _t;}
private:
std::tuple<> _t;
std::queue<std::tuple<>> _queue;
};
#include <iostream>
int main(int ac, char **av) {
Logs log;
Logs log2;
log.write(4, "42");
log.write(Logs(), 4.5f, 42, "toto");
log.write({"hello", "titi"}, 84, "foo");
// std::cout << std::get<0>(log.getTuple()) << std::endl;
return 0;
}
Which could be the type of _t and _queue ?
I would like to push in my queue get one time a std::tuple<int, std::string, Log. float, ...> then a std::tuple<std::vector<std::string>, int, long>, etc. .

Answer 1

You could use a union as the type of your std::queue, like this:
#include <iostream>
#include <queue>
typedef union Data {
int i;
float f;
char str[20];
struct foo {
int a;
char c;
} foo;
struct bar {
int a;
double d;
} bar;
} data;
int main () {
std::queue<data> q;
data mydata;
mydata.i = 5;
q.push(mydata);
data mydata1;
mydata1.f = 3.14;
q.push(mydata1);
data mydata2;
strcpy(mydata2.str, "foo");
q.push(mydata2);
data mydata3;
mydata3.foo.a = 1;
mydata3.foo.c = 'a';
q.push(mydata3);
data mydata4;
mydata4.bar.a = 7;
mydata4.bar.d = 2.78;
q.push(mydata4);
int i = 0;
while(!q.empty()) {
if(i == 0) {
std::cout << ' ' << q.front().i;
} else if(i == 1) {
std::cout << ' ' << q.front().f;
} else if(i == 2) {
std::cout << ' ' << q.front().str;
} else if(i == 3) {
std::cout << ' ' << q.front().foo.a << " " << q.front().foo.c;
} else if(i == 4) {
std::cout << ' ' << q.front().bar.a << " " << q.front().bar.d;
} else {
std::cout << "I do not know what the item has\n";
}
q.pop();
++i;
}
return 0;
}
However, consider that you can not easily use an std::string for example inside a union, either a std::tuple, thus you have to re-think if you can give a shot for the boost::variant, because as you see the code is becoming easily non-maintainable.