可变参数模板与使用元组在参数中添加不同的数据对

Question

following main code works fine

    string hello = "Hello ";
    string world = "templates!";

    cout << "var template add: ";


    cout << setprecision(2) <<
        var_template_add(5, 4, 5.5, 4.0);

for following template generator code and variadic func

template <typename T> 
auto add(T a, T b) {
    return a + b;
}


template <typename T, typename... Rest> 
auto var_template_add(T first, T second, Rest... others) {
    return first + second + add (others...);
}

But if added two more string args, like this

var_template_add(5, 4, 5.5, 4.0, hello, world);

is caught by compiler error saying "no matching overloaded function found".

Again,

string hello = "Hello ";
string world = "templates!";
cout << "strings add result: " << setprecision(2) << add(hello, world) << endl;

could work if i write template function "add" like below:

template <typename T1, typename T2>
auto add(T1 a, T2 b) {
    return a + b;
}

My question is, how could i make the line

var_template_add(5, 4, 5.5, 4.0, hello, world);

work without writing another add function like just above?!

please note i could use tuple to pass this values but for now, i just want to keep away. any thoughts/improvements?

Answer 1

Adding std::string to integral values will not work unless you choose to make your function explicitly convert to string, such as using a std::stringstream or std::to_string .

If you want this to behave correctly with stringizing behavior, you will need to change it to do some form of explicitly string building.

However, you can at least make your current var_template_add work with any number of arguments, since the current definition requires 4 arguments or it will not work. This will allow the var_template_add(hello, world) example to work.

---

In C++11 this can be done by using some template recursion. This doesn't require adding any new functions per-se -- just renaming an existing one and altering one.

The idea is to recursively call the var_template_add until you end up with 2 arguments, and then just add the two together:

// rename'add' to 'var_template_add'. Use this as recursive base-case.
template <typename T, typename U> 
auto var_template_add(T first, U second) 
  -> decltype(first + second)
{
    return first + second;
}

// adds first argument and delegates 'second' and 'others...' to the next 'var_template_add'
template <typename T, typename U, typename... Rest> 
auto var_template_add(T first, U second, Rest... others) 
  -> decltype(first + var_template_add(second, others...))
{
    return first + var_template_add(second, others...);
}

For 2 arguments, it will call the first overload. For 3 or more arguments, it will call the second, which will recursively call into the next var_template_add , until eventually calling into the first.

Note: This answer is because the question is tagged C++11 -- but please be aware that your use of auto return types without a trailing return type is actually C++14 and not C++11.

---

If you have C++17, you can do this even easier using variadic fold expressions:

template <typename T, typename U, typename...Rest>
auto var_template_add(T first, U second, Rest...others)
{
    return first + second + (... + others);
}

---

Edit:

Since OP updated the tags to include c++14 and c++17 , you can achieve the stringizing add behavior quite easily using either to_string or stringstream and a fold expression. For this, I do recommend a different function though -- since appending string sequences is semantically quite a different operation from "adding" values.

The best approach would probably be to use std::stringstream , something like:

template <typename...Args>
std::string variadic_add_str(Args&&...args)
{
    auto stream = std::string_stream{};
    stream << (... << std::forward<Args>(args));
    return stream.str(); 
}

Answer 2

The only way for the current call to work is for var_template_add to return a single type, so it would need to be a string.

Instead, you could write the cout inside the function, so then you only need:

template <typename T, typename... Rest> 
auto var_template_add(T first, T second, Rest... others) {
    cout << setprecision(2) << (first + second) << " ";
    if constexpr (sizeof...(others)) var_template_add(others...);
}

Here's a demo .

Note that there is no if constexpr pre c++17, so in that case, having an extra overload as base case is a good option.