Using a function with a variable number of arguments

Question

Consider the following code:

#include <iostream>

int var_arg_func(...)
{
    std::cout << "Func called!";
}

int main()
{
    var_arg_func(0, 1, 2);
}

As you can see here I can pass a variable number of arguments to the function var_arg_func.

But my question is how can I access those arguments from the function itself? (I'm using C++20)

Why are you using variable arguments instead of a C++ solution like parameter packs? — Stephen Newell, Feb 22 '22 at 14:49
See: https://en.cppreference.com/w/cpp/language/parameter_pack — NathanOliver, Feb 22 '22 at 14:50
Variadic functions are inherited from C and kept around for compatibility with existing code. Since then C++ has added parameter packs which are much safer and I'd argue much easier to use. These are templates with unspecified number of arguments. — François Andrieux, Feb 22 '22 at 14:51
For `var_arg_func(...)`, you would need [`va_arg`](https://en.cppreference.com/w/c/variadic/va_arg) stuff. But prefer variadic template instead. — Jarod42, Feb 22 '22 at 14:52

score 2 · Accepted Answer · answered Feb 22 '22 at 15:20

You can use variadic templates. One example for printing out all the passed argument is given below:

#include <iostream>
//provide an ordinary function to end recursion
void print ()
{
}

template<typename T, typename... Types>
void print (T firstArg, Types... args)
{
    std::cout << firstArg << "\n"; // printing the very first argument passed 
    print(args...); // printing the rest of the argument by calling print()
}

int main()
{
    print(1, 2, 3, "some string literal");//call function template print() with arguments `1`, `2`, `3` and `"some string literal"`
    return 0;
}

In the above snippet, if we call print() with one or more arguments then the templated version of print will be used/called which just prints the very first argument passed(which is 1 in my example) using cout and then calls print with the remaining arguments(which are 2, 3 and "some string literal.

Now the whole process repeats. In particular, the very first argument 2 is printed using cout and then print is called with the remaining arguments(3, "some string literal").

This goes on until there are no more arguments to pass and in this case when print is called with no arguments then the ordinary non-template function print will be used/chosen, thus ending the recursion.

The output of the above program can be seen here:

1
2
3
some string literal

Note that there are other ways as well like using fold expression(with C++17) to do the same. Also, in the above example, the arguments are passed by value. You can modify the program to pass them by reference according to your needs.

With C++17, you can use fold expression:

#include <iostream>
template<class... Args>
void print(const Args&... args)
{
    (std::cout << ... << args) << "\n"; //uses fold expression
}

int main()
{
    print(1, 2, 3, "some string literal");
    return 0;
}

Yes i am aware, the output of the second is `123some string literal`. It can be formatted according to the needs of the user by adding a `Helper` class. Since, there is no such constraint in OP's original question, i didn't bother to do so. I wanted to just show/print the arguments without formatting them. — Jason, Feb 22 '22 at 15:38

Using a function with a variable number of arguments

1 Answers1

Related