Default template specialization with multiple conditions - c++

Question

I'd like to define functions for integral types, string and other types.
I can write:
template<typename T, typename = std::enable_if<std::is_integral<T>::value>::type>
void foo();
template<typename T, typename = std::enable_if<std::is_same<std::string>::value>::type>
void foo();
But how I can define function that will be called in other cases (if T not integral type and not std::string)?

Answer 1

I'm pretty sure that writing something like the line below becomes quite annoying and error-prone when you want to write up to N sfinae'd versions of foo:
std::enable_if<!std::is_integral<T>::value && !std::is_same<T, std::string>::value>::type
To avoid it, you can use the choice trick (a simple way to exploit overload resolution actually).
It follows a minimal, working example:
#include <iostream>
#include <utility>
#include <string>
template<int N> struct Choice: Choice<N-1> {};
template<> struct Choice<0> {};
template<typename T, typename... Args>
std::enable_if_t<std::is_integral<T>::value>
bar(Choice<2>, Args&&...) { std::cout << "integral" << std::endl; }
template<typename T, typename... Args>
std::enable_if_t<std::is_same<T, std::string>::value>
bar(Choice<1>, Args&&...) { std::cout << "string" << std::endl; }
template<typename T, typename... Args>
void bar(Choice<0>, Args&&...) { std::cout << "whatever" << std::endl; }
template<typename T, typename... Args>
void foo(Args&&... args) { bar<T>(Choice<100>{}, std::forward<Args>(args)...); }
int main() {
foo<bool>("foo");
foo<std::string>(42);
foo<void>(.0, "bar");
}
It handles nicely also the arguments that are directly forwarded to the right function once it has been picked up from the set.
The basic idea is that it tries to use all the versions of your function in the order you specified, from N to 0. This has also the advantage that you can set a priority level to a function when two of them match the template parameter T with their sfinae expressions.
The sfinae expressions enable or disable the i-th choice and you can easily define a fallback by using the Choice<0> tag (that is far easier to write than std::enable_if<!std::is_integral<T>::value && !std::is_same<T, std::string>::value>::type).
The drawback (even though I wouldn't consider it a drawback) is that it requires an extra function that simply forwards the arguments to the chain by appending them to the Choice<N> tag.
See it up and running on Coliru.

Answer 2

Your examples do not compile at all for many reasons. See proper SFINAE in the code below. This is only one of many possible ways to do it.
You can just negate all special conditions simultaneously. For example:
template<typename T, std::enable_if_t<std::is_integral<T>::value>* = nullptr>
void foo() { std::cout << "Integral\n"; }
template<typename T, std::enable_if_t<std::is_same<T, std::string>::value>* = nullptr>
void foo() { std::cout << "Str\n"; }
template<typename T, std::enable_if_t<!std::is_integral<T>::value && !std::is_same<T, std::string>::value>* = nullptr>
void foo() { std::cout << "Something else\n"; }
int main(void)
{
foo<int>();
foo<std::string>();
foo<float>();
return 0;
}
prints:
Integral
Str
Something else
Note that you may get automatic overload resolution if your functions take template-dependent arguments. SFINAE will look a bit different in this case:
template<typename T>
typename std::enable_if<std::is_integral<T>::value>::type foo(const T&) { std::cout << "Integral\n"; }
template<typename T>
typename std::enable_if<std::is_same<T, std::string>::value>::type foo(const T&) { std::cout << "Str\n"; }
template<typename T>
typename std::enable_if<!std::is_integral<T>::value && !std::is_same<T, std::string>::value>::type
foo(const T&) { std::cout << "Something else\n"; }
Usage:
foo(1);
foo(std::string("fdsf"));
foo(1.1f);
Finally, in the last case std::string overload may be on-template function:
template<typename T>
typename std::enable_if<std::is_integral<T>::value>::type foo(const T&) { std::cout << "Integral\n"; }
template<typename T>
typename std::enable_if<!std::is_integral<T>::value && !std::is_same<T, std::string>::value>::type
foo(const T&) { std::cout << "Something else\n"; }
void foo(const std::string&) { std::cout << "Str\n"; }

Answer 3

#Jarod42 was right.
I chose the wrong way to use SFINAE.
Actually, I had to use std::enable_if in return type declaration. And in order to define 'default' function (for all other types) I just need to define function with the same name and with ... as input parameters.
template<typename T>
std::enable_if_t<std::is_integral<T>::value>
foo() { std::cout << "integral"; }
template<typename T>
std::enable_if_t<std::is_same<T, std::string>::value>
foo() { std::cout << "string"; }
template<typename T>
void foo(...) { std::cout << "other"; }