// ?? template<class TInt> ??
void f(/*TInt */) {} // (1)

// ?? template<class unsigned TInt> ??
void f(/*TInt */) {} // (2)

void main()
{
    int i;
    unsigned int ui;
    f(i); // call (1) for any signed type
    f(ui); // call (2) for any unsigned type
}

А>// ?? template<class TInt> ??
А>void f(/*TInt */) {} // (1)

А>// ?? template<class unsigned TInt> ??
А>void f(/*TInt */) {} // (2)

А>void main()
А>{
А>    int i;
А>    unsigned int ui;
А>    f(i); // call (1) for any signed type
А>    f(ui); // call (2) for any unsigned type
А>}
А>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/integral_constant.hpp>

template<class T>
struct is_signed_type : public boost::false_type
{};

template<class T>
struct is_unsigned_type : public boost::false_type
{};

// Специализируем...

template<>
struct is_signed_type<int> : public boost::true_type
{};

template<>
struct is_unsigned_type<unsigned int> : public boost::true_type
{};

template<class T>
typename boost::enable_if< is_signed_type<T> >::type f(T val)
{
    std::cout << val << " : signed" << std::endl;
}

template<class T>
typename boost::enable_if< is_unsigned_type<T> >::type f(T val)
{
    std::cout << val << " : unsigned" << std::endl;
}

int main(int argc, char * argv[])
{
    int i = -1;
    unsigned int j = 1;

    f(i);
    f(j);

    return 0;
}

template<class SignedType>
f_signed_impl(SignedType i)
{
//Общая реализация для знаковых типов
}

template<class UnsignedType>
f_unsigned_impl(UnsignedTypei)
{
//Общая реализация для беззнаковых типов
}

f(unsigned char uc) { f_unsigned_impl(uc); }
f(signed char sc) { f_signed_impl(sc); }
f(char c) { f_signed_impl(c); }
...//перегрузки для остальных типов

template <class T>
struct is_signed;// Только объявление (использоваться могут только явные специализации)

//Вспомогательные типы
struct signed_type {};
struct unsigned_type {};

//Специализации для встроенных типов
template<>
struct is_signed<char>
{
   typedef signed_type type;
};

template<>
struct is_signed<signed char>
{
   typedef signed_type type;
};

template<>
struct is_signed<short>
{
   typedef signed_type type;
};

template<>
struct is_signed<unsigned char>
{
   typedef unsigned_type type;
};

template<>
struct is_signed<unsigned short>
{
   typedef unsigned_type type;
};


template <class T>
void f(T t, signed_type*)
{
//Общая реализация для знаковых типов
}

template <class T>
void f(T t, unsigned_type*)
{
//Общая реализация для беззнаковых типов
}

template <class T>
void f(T t)
{
   //В зависимости от типа T компилятор выберет соответствующую реализацию
   f(t, static_cast<typename is_signed<T>::type*>(0));
}

int main()
{
    short i;
    unsigned short ui;
    f(i);
    f(ui);

   return 0;
}

А>Спасибо. Я, к сожалению, забыл сказать, что буст у нас не используется

#include <limits>

// специально для бустофобов
template<bool V, class T> struct enable_if_c {};
template<class T> struct enable_if_c<true,T> { typedef T type; };




template<class T>
enable_if_c<
    std::numeric_limits<T>::is_integer &&
    std::numeric_limits<T>::is_signed,
    void >::type
    foo(T x) { std::cout << "signed integer"; }

template<class T>
enable_if_c<
    std::numeric_limits<T>::is_integer &&
    !std::numeric_limits<T>::is_signed,
    void >::type
    foo(T x) { std::cout << "unsigned integer"; }

template<class T>
enable_if_c<
    !std::numeric_limits<T>::is_integer &&
    std::numeric_limits<T>::is_specialized
    void >::type
    foo(T x) { std::cout << "float"; }

template<class T>
enable_if_c<
    !std::numeric_limits<T>::is_specialized
    void >::type
    foo(T x) { std::cout << "not a number"; }