#include <limits>
#include <type_traits>
#include <iostream>

template <typename T> struct unsigned_integer_traits;
template <> struct unsigned_integer_traits<unsigned char> {
  typedef signed char signed_type;
};
template <> struct unsigned_integer_traits<unsigned short int> {
  typedef signed short int signed_type;
};
template <> struct unsigned_integer_traits<unsigned int> {
  typedef signed int signed_type;
};
template <> struct unsigned_integer_traits<unsigned long int> {
  typedef signed long int signed_type;
};
template <> struct unsigned_integer_traits<unsigned long long int> {
  typedef signed long long int signed_type;
};


template <typename T>
struct is_2complement_system {
  typedef typename unsigned_integer_traits<T>::signed_type signed_type;
  static const bool value = (static_cast<signed_type>(~(T())) 
                             == static_cast<signed_type>(-1));
};
template <typename T>
const bool is_2complement_system<T>::value; 

template <typename T, bool is_2complement_system_value>
struct unsigned_to_signed_impl;

template <typename T>
struct unsigned_to_signed_impl<T,true> {
  typedef typename unsigned_integer_traits<T>::signed_type signed_type;
  static signed_type convert(T value) 
  { 
     return static_cast<signed_type>(value); 
  }
};

template <typename T>
struct unsigned_to_signed_impl<T,false> {
  typedef typename unsigned_integer_traits<T>::signed_type signed_type;
  static signed_type convert(T value) 
  { 
     // well do something complicated you don't care what
     return T(); // just for tests 
  }
};

template <typename T>
typename unsigned_integer_traits<T>::signed_type  unsigned_to_signed(T n)
{
    return unsigned_to_signed_impl<T,is_2complement_system<T>::value>::convert(n);
}

int main() {
  std::cout 
    << unsigned_to_signed(100u) << '\n'
    << unsigned_to_signed(0xFFFFffff) << '\n'
;

}