C++ templates: call whichever function matches between 2 choices

Question

How can I call the function that matches using C++ templates? For example if I have the functions a and b:

void a_impl(string, int){}
void b_impl(int, string){}

template
void a(X x, Y y){
  a_impl(x, y);
}

template
void b(X x, Y y){
  b_impl(x, y);
}

template
void a_or_b(X x, Y y);

How do I implement a_or_b such that it calls a(x, y) if it matches, otherwise call b(x, y)?

What I'm trying to make is a for_each function that can handle these cases:

vector> v1 = {{"one", 1}, {"two", 2}};

for_each(v1, [](string x, int y){
  cout << x << " " << y << endl;
});

vector v2 = {1, 2, 3};

for_each(v2, [](int x){
  cout << x << endl;
});

So far I have it working for both tuples and single variables independently but I want the appropriate version to be selected automatically. Here is my implementation so far; unpack is apply_from_tuple from this page http://www.cppsamples.com/common-tasks/apply-tuple-to-function.html.

template
void for_each_unpack(Range && range, Func && func){
  for (auto && element : range){
    using Element = decltype(element);
    unpack(std::forward(func), std::forward(element));
  }
}

template
void for_each_nounpack(Range && range, Func && func){
  for (auto && element : range){
    using Element = decltype(element);
    std::forward(func)(std::forward(element));
  }
}

Edit: Got it working thanks to @jotik. I put the code on github https://github.com/csiz/for_each.

jotik · Accepted Answer

Use a trailing return type with decltype and SFINAE:

#include 
#include 
#include 


void a(std::string, int) { std::cout << "a" << std::endl; }
void b(int, std::string) { std::cout << "b" << std::endl; }

template 
auto a_or_b(Args && ... args)
    -> decltype(a(std::forward(args)...))
{ return a(std::forward(args)...); }

template 
auto a_or_b(Args && ... args)
    -> decltype(b(std::forward(args)...))
{ return b(std::forward(args)...); }

int main() {
    std::string s;
    int i;
    a_or_b(s, i); // calls a
    a_or_b(i, s); // calls b
}

I've used perfect forwarding in the above example because it avoids a copy for each argument, but the less general naive solution with explicit types also works:

template 
auto a_or_b(X x, Y y) -> decltype(a(x, y))
{ return a(x, y); }

template 
auto a_or_b(X x, Y y) -> decltype(b(x, y))
{ return b(x, y); }

How SFINAE works in this case is as follows. Note that there are 2 template definitions for a_or_b. And when you write a function call to a_or_b the compiler tries to figure out which a_or_b you meant to call. Due to SFINAE, it ignores any template a_or_b for which it is unable to deduce the type for. E.g. for the call a_or_b(s, i); the (trailing) return type decltype(b(std::forward(args)...)) for the second a_or_b definition does not work, therefore the second a_or_b definition is not considered by the compiler.

In this case the return type is required to be a trailing return type, because it depends on the function arguments. For example, the following would not compile:

template 
decltype(b(std::forward(args)...)) a_or_b(Args && ... args)
{ return b(std::forward(args)...); }

C++ templates: call whichever function matches between 2 choices

Answers (2)

Related Questions