print a list of numbers using template metaprogramming - c++

Question

I am unable to figure out why does following code not compile. Could you guys please help me?
#include <iostream>
template <typename T, typename ...Args>
void foo(T i, Args ... args){
std::cout << i << std::endl;
foo(args...);
}
template <typename T>
void foo(T i){
std::cout << i << std::endl;
std::cout << "end of list" << std::endl;
}
int main(){
foo(1, 2);
return 0;
}
I get the following error
function_parameter_pack.cpp: In instantiation of ‘void foo(T, Args ...) [with T = int; Args = {}]’:
function_parameter_pack.cpp:18:6: required from ‘void foo(T, Args ...) [with T = int; Args = {int}]’
function_parameter_pack.cpp:47:11: required from here
function_parameter_pack.cpp:18:6: error: no matching function for call to ‘foo()’
foo(args...);
~~~^~~~~~~~~
function_parameter_pack.cpp:16:6: note: candidate: template<class T, class ... Args> void foo(T, Args ...)
void foo(T i, Args ... args){
^~~
function_parameter_pack.cpp:16:6: note: template argument deduction/substitution failed:
function_parameter_pack.cpp:18:6: note: candidate expects at least 1 argument, 0 provided
foo(args...);
It seems error is happening during base case. But I am not able to understand why.
I tried following base-case also but got the same error
void foo(){
std::cout << "end of list" << std::endl;
}

Answer 1

Functions must be declared before they can be called. Change the order of functions.
Your special case is not a specialization of the base case, so the base case cannot see it. Because the template argument list is different, it is simply an overloaded function.
template <typename T>
void foo(T i){
std::cout << i << std::endl;
std::cout << "end of list" << std::endl;
}
template <typename T, typename ...Args>
void foo(T i, Args ... args){
std::cout << i << std::endl;
foo(args...);
}

Answer 2

You already got answers with a fix for the immediate problem you are facing. I want to add that your example isn't using the full power of fold expressions as they become available with C++17. If you can upgrade to a more recent standard, I strongly suggest you to do so.
You are using a fold expression here foo(args...) to recursively instantiate foos with different number of arguments. This isn't needed. Recursion was the "old" way to implent your code, fold expressions is the more modern way. You can mix them, but you don't need to:
#include <iostream>
template <typename ...Args>
void foo(Args ... args){
(std::cout << ... << args) << std::endl;
}
int main(){
foo(1, 2);
return 0;
}
Note that there is only a single instantiation of foo required. No recursion, hence no unnecessary functions that you don't really need (if you only ever call foo with 2 parameters, then you do not need a foo that takes 1).

Answer 3

Swap the order of the functions (the one taking multiple arguments calls the one taking one argument, so the single argument function must have been declared) and make the function that takes a single argument take the argument as T, not int - or else the template argument deduction will fail.
template <typename T>
void foo(T i) {
std::cout << i << std::endl;
std::cout << "end of list" << std::endl;
}
template <typename T, typename ...Args>
void foo(T i, Args... args){
std::cout << i << std::endl;
foo(args...);
}