Problem when trying to obtain an std::reference_wrapper with a particular template class parameter

Question

I am struggling with a problem that I am not able to solve. I searched all around the website and web in general and didn't find any solution (maybe this is due to the fact that I doesn't understand well something and I am not able to ask it correctly).

The problem is the following, supposing I have a template class with some parameters, whose one of them is a tempate itself, defined in a class.h file:

template

Ted Lyngmo · Accepted Answer

You'll need a common base for the elements you store references too. This could be one way:

struct ProgressBarBase {
    // Optional: A virtual destructor if you want to delete objects via
    // base class pointers:
    virtual ~ProgressBarBase() = default;
};

template 
struct ProgressBar : public ProgressBarBase {};

With that, you could change your class slightly to store references to ProgressBarBase (or whatever indicator base class you'd like).

template 
class MultiProgressBar {
public:
    template = 0>
    MultiProgressBar(Indicators&&... bars)
        : bars_{std::forward(bars)...}
    {
        // or this instead of SFINAE:
        static_assert(sizeof...(Indicators) == count, "wrong number of arguments");
    }

private:
    std::array, count> bars_;
};

int main() {
    ProgressBar prog_int;
    ProgressBar prog_double;
    ProgressBar prog_float;

    MultiProgressBar bars(prog_int, prog_double, prog_float);
}

However, if you for example have a function, like void update(bar_type value); in ProgressBar, making it virtual in the base class will not work (since bar_type is not known in the base class).

One option could be to drop the std::array and use a std::tuple instead. This makes it possible to keep the type information and it also gets rid of the need for the a base class. You also do not need the reference_wrapper since the references won't be stored in an array.

C++17 example:

template 
struct ProgressBar{
    void update(bar_type v) {
        std::cout << value << '
';
        value = v;     
    }

    bar_type value;
};

template 
class MultiProgressBar {
public:
    template
    MultiProgressBar(Inds&&... bars) : bars_{std::forward(bars)...} {}

    void update() {
        std::apply([](auto&... rw){
            (rw.update(0), ...);
        }, bars_);
    }

private:
    std::tuple bars_;
};

// deduction guide
template
MultiProgressBar(Indicators...) -> MultiProgressBar;

C++17 Demo

I didn't notice the C++11 tag until I had finished the above. Here's a C++11 example too. It's a lot more to implement but I couldn't think of an easier way to do it right now:

#include 
#include 
#include 

// A type to generate indices for parameter packs:
template
struct indices { };

template
struct gen_indices : gen_indices { };

template
struct gen_indices<0, Is...> : indices { };

template 
struct ProgressBar{
    void update(bar_type v) {
        std::cout << value << '
';
        value = v;     
    }

    bar_type value;
};

template 
class MultiProgressBar {
public:
    template
    MultiProgressBar(Inds&&... bars) : bars_{std::forward(bars)...} {}

    void update() {
        // call the update overload what takes an indices
        update(gen_indices());
    }

private:
    template
    void update(indices) {
        // call update on every element in the tuple
        // , 0 is done to discard the `void` return from `update`
        // to build a dummy initializer list (since C++11 lacks fold expressions)
        auto dummy = { (std::get(bars_).update(0), 0)... };
        (void) dummy; // quiet warning about unused variable
    }

    std::tuple bars_;
};

// Since deduction guides doesn't exist in C++11, we'll add a helper function:
template
MultiProgressBar::type...>
make_MultiProgressBar(Indicators&&... inds) {
    return {std::forward(inds)...};
}

int main() {
    ProgressBar prog_int{1};
    ProgressBar prog_double{2};
    ProgressBar prog_float{3};

    auto bars = make_MultiProgressBar(prog_int, prog_double, prog_float);
    bars.update();

    // all set to 0:
    std::cout << prog_int.value << prog_double.value << prog_float.value << '
';
}

C++11 Demo

For C++11 you could make it simpler by making it possible to provide functors containing the function you want to call for all elements in the tuple:

template 
class MultiProgressBar {
public:
    template
    MultiProgressBar(Inds&&... bars) : bars_{std::forward(bars)...} {}

    static size_t size() { return sizeof...(Indicators); }

    template 
    void for_one(size_t idx, Func&& func, Args&&... args) {
        call_one(idx, gen_indices(),
                 std::forward(func), std::forward(args)...);
    }

    template
    void for_each(Func func, Args&&... args) {
        // call `call_all` that takes an indices
        // with a function and the arguments to pass to the function
        call_all(gen_indices(), func, std::forward(args)...);
    }

private:
    template 
    void call_one(size_t idx, indices, Func&& func, Args&&... args) {
        [](...) {} ( // define a dummy lambda that takes any arguments and call it
            // with the below as arguments. Short-circuit evaluation makes sure
            // that `func` only gets called when `idx == Ids`
            (idx == Ids && // (void) below to avoid warnings about unused return vals
                     ((void)std::forward(func)(
                          std::get(bars_), std::forward(args)...),
                      false))...
        );   
    }

    template
    void call_all(indices, Func&& func, Args&&... args) {
        // call `func` with every element in the tuple
        // ", 0" is done to discard the `void` return from `update`
        // to build a dummy initializer list (since C++11 lacks fold expressions)
        auto dummy = { (func(std::get(bars_), args...), 0)... };
        (void) dummy; // quiet warning about unused variable
    }

    std::tuple bars_;
};

A functor could then look like this:

template< class T > // borrowed from c++20
struct type_identity { using type = T; };

struct updater { // instead of a lambda with auto as argument type
    template class PB, class bar_type>
    auto operator()(PB& pb, 
                    typename type_identity::type v) const -> decltype(pb.update(bar_type{}))
    {
        return pb.update(v);
    }
};

and be used like this:

int main() {
    ProgressBar prog_int{1};
    ProgressBar prog_double{2};
    ProgressBar prog_float{3};

    auto bars = make_MultiProgressBar(prog_int, prog_double, prog_float);
    bars.for_each(updater{}, 4);

    // all set to 4:
    std::cout << prog_int.value << '
'
              << prog_double.value << '
'
              << prog_float.value << '
';

    for(size_t i = 0; i < bars.size(); ++i) {
        bars.for_one(i, updater{}, i);
    }

    // 0, 1 and 2
    std::cout << prog_int.value << '
'
              << prog_double.value << '
'
              << prog_float.value << '
';    
}

Demo

Problem when trying to obtain an std::reference_wrapper with a particular template class parameter

Answers (1)

Related Questions