Can we just have one function with variadic templates?

Question

I am taking the code from the solution to one of the old question from here

#include <utility>
#include <iostream>
class Test {
  public:
  Test() {
      std::cout << "ctor" << std::endl;
  }
  Test(const Test&) {
      std::cout << "copy ctor" << std::endl;
  }
  Test(Test&&) {
      std::cout << "move ctor" << std::endl;
  }
};

void func(Test const&)
{
    std::cout << "requires lvalue" << std::endl;
}

void func(Test&&)
{
    std::cout << "requires rvalue" << std::endl;
}

template<typename Arg>
void pass(Arg&& arg) {
    // use arg here
    func(std::forward<Arg>(arg));
    return; 
}

template<typename Arg, typename ...Args>
void pass(Arg&& arg, Args&&... args)
{
    // use arg here
    return pass(std::forward<Args>(args)...);
}

int main(int, char**)
{
    pass(std::move<Test>(Test()));
    return 0;
}

I am wondering if there exists a way to avoid having 2 overloads of the function called pass above something like void pass(Arg&& ...arg) and still achieve the same functionality as above?

It confuses me to understand when do I need to overloads like taken in above code.

note that this code is rather old-fashioned. It uses recursion (which isnt needed nowadays) and as always with recursion you need to stop somewhere — 463035818_is_not_an_ai, Jan 18 '22 at 10:57
@463035818_is_not_a_number : exactly that's where I am getting confused and thought if there is rewrite possible now a days to make it simple. — Test, Jan 18 '22 at 11:01
It is bad usage of `std::move` in `pass(std::move(Test()));`, `std::move` deduce it argument so `` should be removed; `Test()` is already a r-value, so `std::move` is unneeded. — Jarod42, Jan 18 '22 at 11:04

Jarod42 · Answer 1 · 2022-01-18T11:09:45.120

4

In C++17, your might use fold expressions:

template <typename ... Ts>
void pass(Ts&&... args)
{
    [[maybe_unused]] auto f = [](auto&& arg){ /* use arg here */};
    (f(std::forward<Ts>(args)), ...);
    func((std::forward<Ts>(args), ...)); // call func only on last parameter
                                      // (assuming no evil overload of operator,)
}

edited Jan 18 '22 at 11:09

answered Jan 18 '22 at 10:58

Jarod42

203,559
14
181
302

You're missing the final call of the global `func` on the last element of `args`. – Holt Jan 18 '22 at 11:00
@Holt: Not sure if it is not a typo of OP, else `func((std::forward(args), ...));` should do the trick. Added anyway. – Jarod42 Jan 18 '22 at 11:08
Nice trick You probably don't want to `std::forward` on `args` when calling `f` then. – Holt Jan 18 '22 at 12:44
@Jarod42 : Can you explain a bit the magic you did? Won't (f(std::forward(args)), ...); expand "all" args including the last one? And how will func((std::forward(args), ...)); be called only on the last arg? I think you are doing multiple things here. – Test Jan 20 '22 at 08:09
@Test: Trick is to use comma operator `(a, .., z)` would evaluate `a`, .., `z` (AND return `z`) (assuming no evil overload comma operator). so `(f(args), ...)` is `(f(a), .., f(z))`; on the other side `f((args, ...))` is `f((a, .., z))` and so `f(z)`. – Jarod42 Jan 20 '22 at 09:14

score 1 · Answer 2 · answered Jan 18 '22 at 11:15

Not exactly what you asked but... observe that (also before C++17) instead of a template ground-case recursion function that receive an arg and duplicate the single arg management

template <typename Arg>
void pass (Arg && arg) {
    func(std::forward<Arg>(arg));
}

you can simply write a non-template empty (no arg received, no arg managed) pass() function

void pass ()
{ }

Can we just have one function with variadic templates?

2 Answers2