将可变参数函数模板参数存储到union向量中的最有效方法是什么？

Question

我有一个简单的联合,其构造函数将其参数存储在相关成员中:

union Data
{
    Data(int    i) : _i(i) { }
    Data(double d) : _d(d) { }
    Data(char   c) : _c(c) { }

    int    _i;
    double _d;
    char   _c;
};

然后我有一个可变参数构造函数,它接受这些类型的参数并使用模板递归将它们存储在union的向量中:

template<typename... Ts>
DataStore(Ts... ts)
{
    _data.reserve(sizeof...(ts));
    store(ts...);
}

template<typename T, typename... Ts>
void store(T t, Ts... ts)
{
    _data.push_back(t);
    store(ts...);
}

void store()
{
    // terminal condition
}

这将导致一系列vector::push_back与参数数量匹配的调用.

这是填充联合向量的最有效/最快的方法吗？

有什么技巧(可以特定于x86-64/Linux)我可以用来加快速度吗？

工作范例:

#include <iostream>
#include <vector>

union Data
{
    Data(int    i) : _i(i) { }
    Data(double d) : _d(d) { }
    Data(char   c) : _c(c) { }

    int    _i;
    double _d;
    char   _c;
};

struct DataStore
{
    template<typename... Ts>
    DataStore(Ts... ts)
    {
        _data.reserve(sizeof...(ts));
        store(ts...);
    }

    template<typename T, typename... Ts>
    void store(T t, Ts... ts)
    {
        _data.push_back(t);
        store(ts...);
    }

    void store()
    {
        // terminal condition
    }

    std::vector<Data> _data;
};

int main()
{
    DataStore d(1, 2.3, 'c');

    std::cout << d._data.size() << '\n'
              << d._data[0]._i  << '\n'
              << d._data[1]._d  << '\n'
              << d._data[2]._c  << '\n';

    return 0;
}

Answer 1

您可以_data直接初始化.

template<typename... Ts>
DataStore(Ts... ts) : _data{ts...}
{}