Implementation of typed tuple wrapper

Question

How can an implementation look like, that wraps around e.g. a std::tuple as a static list of type/value, plus a type (not contained in tuple) to refer to some kind of owner/visitor.

I want to instantiate like

constexpr auto data = data_of<a>(1, 2.0);

Background

The idea is to use a data_of<T>(...) kind of structure to to pass a list of type/data pairs into a bulk function like this.

template <typename... _Ts>
static constexpr void do_bulk_stuff(_Ts&&... _Vs)
{
    // crazy stuff happens here
}
// call it like
do_bulk_stuff
(
    data_of<a>(1, 2.0), 
    data_of<b>(3), 
    data_of<c>(4.0, 5, 6),
    // ...
);

Attempt 1

So far I ended up with a naive (not working) implementation attempt like

template <typename T, typename... Ts>
struct data_of {
    using type = T;
    using data_t = std::tuple<Ts...>;
    data_t data;
    
    constexpr data_of(Ts&&... Vs)
    : data(Vs...)
    {}
};

Goal

My goal is to achieve a result like this data_of<a> instance pseudo code example

{
    // meta
    type = a;
    data_t = std::tuple<int,double>;

    // runtime
    data = [1, 2.0];
}

It appears that it cannot deduce Vs in the constructor function. — Mechap
– Mechap, Commented Apr 12, 2022 at 10:50
[off topic] Identifiers that begin with an underscore followed by an uppercase letter are reserved. — VainMan
– VainMan, Commented Apr 12, 2022 at 13:47

StoryTeller - Unslander Monica · Accepted Answer · 2022-04-12 11:28:08Z

3

The issue inherent to your attempt is that class template argument deduction is simply not like its function counterpart. There will be no deduction if any of the class template's arguments is explicitly specified. You fail because the trailing pack is always specified (by omission) as empty.

The solution is to shift the burden onto the mechanism that allows you to specify only part of the arguments: function templates.

template <typename T, typename... Ts>
struct data_of_t {
    using type = T;
    using data_t = std::tuple<Ts...>;
    data_t data;
    
    constexpr data_of_t(Ts&&... vs)
    : data(std::forward<Ts>(vs)...)
    {}
};

template<typename T, typename... Ts>
constexpr auto data_of(Ts&&... vs) {
    return data_of_t<T, Ts...>(std::forward<Ts>(vs)...);
}

Now the type of the expression data_of<a>(1, 2.0) has the same "meta" properties you are after.

edited Apr 12, 2022 at 11:28

answered Apr 12, 2022 at 10:51

StoryTeller - Unslander Monica

172k22 gold badges401 silver badges481 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Implementation of typed tuple wrapper

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related