How would you apply an same operation to a set of independent variables in C++?

Question

Edit Totally forgot to mention smth that's obvious to me:

a_func() wants to modify the var_xxx, so the solutions that iterate using a const type aren't completely satisfying (although they bring in ideas, for sure).

I feel the answer is simple yet can't find it.

Given:

A number (a small number, like 6, 8, 10) of variables of a user class type (precisely, a math vector object), where each variable has to have a unique name, defined by the algorithm (in order to be calculated and then used independently, and to be able to easily consult the paper that the code is based on)

Do:

In a piece of code, calculate and initialize those variables, referring to them by name; and then in another piece of code perform an operation on them in a sweep, without having to duplicate the code calling the operation (i.e. a function) for each and every variable.

Code goes like this:

// in a class declaration
vector_type var_abc, var_efg, var_xyz;

// in a class member function
// "some_math_xxx" pieces are coded inline, not as separate functions
var_abc = /* some_math_abc */;
var_efg = /* some_math_efg */ ;
var_xyz = /* some_math_xyz */ ;
a_func(var_abc); a_func(var_efg); a_func(var_xyz);

I mean, I can of course type a_func(var_xxx) six or more times. But it, well, feels just wrong to me.

Thought of:

• a hash to store the names of those cars (bad for the math using them later I guess)
• a std::array<> of pointers to the vars (bit clumsy but works)

• this code that fails to compile:

  for (vector_type& vr : { var_abc, var_efg, var_xyz }) { a_func(vr); } (error: binding const vector_type to reference of type vector_type&)

How would you solve this? I'd prefer an elegant solution, of course. The standard better be just C++11, though C++14 is ok too if it enables a super cute solution to this problem.

P.S. The question entering form says "the title is subjective and the Q may be closed". I'm sure this is not an opinion-based Q, as I'm not asking to compare the solutions, but to suggest some.

Answer 1

I'd write a recursive function that applies a functor to a set of variables:

#include <functional>

template<typename Functor, typename First, typename Second, typename ... Others>
auto apply_over(Functor &&fn, First &&var0, Second &&var1, Others &&... vars){
    fn(std::forward<First>(var0));
    apply_over(std::forward<Second>(var1), std::forward<Others>(vars)...);
}

template<typename Functor, typename Var>
auto apply_over(Functor &&fn, Var &&var){
    fn(std::forward<Var>(var));
}

And use it like so:

auto main() -> int{
    var_type var0, var1, var2;

    apply_over([](var_type &var){ /* do something with var */ }, var0, var1, var2);
}

Or even better (more generic) with C++14:

auto main() -> int{
    var_type var0;
    int var1;
    float var2;

    // no need to worry about types!
    apply_over([](auto &var){ var += decltype(var)(1); }, var0, var1, var2);
}

Or with your function a_func:

auto main() -> int{
    var_type var0, var1, var2;

    apply_over(a_func, var0, var1, var2);
}

Answer 2

The issue seems to be that you were trying to initialise a reference with a const value copied to the implicit initializer_list. This container, like all others, cannot contain references. So, instead, you get const values, since initializer_list (currently? and probably forever) only offers const access to its members.

So... just use pointers to the elements. They're not to be feared. This seems simple:

for ( auto const it: /* std::initializer_list<VecType *> */ {&vecA, &vecB, &vecC} ) {
    doStuff(*it);
    // N.B. it is a *const, not a const *const!
}

You don't need to explicitly specify the initializer_list type, as long as you're not using elements of various polymorphic pointer types or that require conversion operators (in which case, you do).

Unless I'm missing something, others' suggestions of putting everything through an extra layer of std::reference_wrapper seems to be an unnecessary hoop to jump through, just to avoid pointers for some reason. Other solutions might invoke copies, which could lead to a lot of confusion.

I kinda wish C++ had a range-for style 'automatic dereference` for this case, but getting that implemented would probably cause all kinds of syntactic ambiguity, which wouldn't really be worth it when it's simple enough this way.

Answer 3

Your code: for (vector_type& vr : { var_abc, var_efg, var_xyz }) { a_func(vr); } creates an initializer_list:

An object of type std::initializer_list<T> is a lightweight proxy object that provides access to an array of objects of type const T

So you cannot invoke a modifying function on them.

Instead use ref: for (auto& vr : { ref(var_abc), ref(var_efg), ref(var_xyz) }) { a_func(vr); }

Live Example

Answer 4

If you want to achieve the effect of copy pasting the function call without actual copy pasting, then use this variadic template trick:

template<typename ... Args>
void call_a_func (Args&&... args)
{
  int unused[] = { (a_func(std::forward<Args>(args)), 0) ... }; (void) unused;
}

Usage:

call_a_func(var_abc, var_efg, var_xyz, var_pqr);

I have simplified your problem in this Demo. You may extend it further. This trick is mentioned at various places in SO, I picked up from this post.

Answer 5

If you want an unfolded loop, you might be interested in for_each_arg:

template<class F, class...Ts>
F for_each_arg(F f, Ts&&...a) {
  return (void)std::initializer_list<int>{(f((Ts&&)a),0)...}, f;
}

Usage:

for_each_arg(a_func, var_abc, var_efg, var_xyz);

Of course, if you have to operate on the same set of variables repeatedly, it might be better to define an array of pointers and use iteration.

References:

https://twitter.com/ericniebler/status/559119062895431680

https://youtu.be/Za92Tz_g0zQ

https://github.com/SuperV1234/cppnow2015