#include <iostream>
#include <type_traits>
#include <utility>
using namespace std;
 
class empty_type {};
 
template<typename T, typename A = empty_type>
struct has_foo : std::false_type {};
 
template<class T>
struct has_foo<T, decltype(std::declval<T>().foo(int()))> : std::true_type {};
 
struct bad_foo_1
{
    void foo(int);
};
 
struct bad_foo_2
{
    int foo(int);
};
 
struct good_foo
{
    empty_type foo(int);
};
 
int main()
{
    std::cerr << std::boolalpha;
    std::cerr << has_foo<int>::value << std::endl;
    std::cerr << has_foo<bad_foo_2>::value << std::endl;
    std::cerr << has_foo<bad_foo_1>::value << std::endl;
    std::cerr << has_foo<good_foo>::value << std::endl;
 
    return 0;
}

template<typename T, typename A = void>
struct has_foo : std::false_type {};
 
template<class T>
struct has_foo<T, decltype(std::declval<T>().foo(int()))> : std::true_type {};

struct good { void foo(int); };
 
...
 
std::cout << has_foo<good>::value << std::endl;

template<class T>
struct has_foo<T, decltype(std::declval<T>().foo(int()))>  // можно инстанцировать как has_foo<good, void>
    : std::true_type {};

struct bad  { int foo(int) ; };

template<class T>
struct has_foo<T, decltype(std::declval<T>().foo(int()))>  // нельзя инстанцировать как has_foo<bad, void>
    : std::true_type {};

#include <iostream>
 
// общий случай: когда T - char
template<class T, bool is_char = ::std::is_same<T, char>::value>
struct sample
{
    enum { value = 1 };
};
 
// специализация сработает, когда T - не char
template<class T>
struct sample<T, false>
{
    enum { value = 0 };
};
 
 
int main()
{
    // второй параметр выведется как false
    // sample<int, false> подходит к специализации
    std::cout << "is char?  " << sample<int>::value  << '\n'; 
    
    // второй параметр выведется как true
    // sample<char, true> подходит только базовому шаблону
    std::cout << "is char?  " << sample<char>::value << '\n'; 
}