if both of its arguments are actually references to the same object

#include <iostream>

template <bool B, class T = void>
struct enable_if_c {
    typedef T type;
};

template <class T>
struct enable_if_c<false, T> {};

template <class Cond, class T = void>
struct enable_if : public enable_if_c<Cond::value, T> {};

template <bool B, class T = void>
struct disable_if_c {
    typedef T type;
};

template <class T>
struct disable_if_c<true, T> {};

template <class Cond, class T = void>
struct disable_if : public disable_if_c<Cond::value, T> {};

template < typename T, typename U >
typename disable_if_c<is_convertible<T*, U*>::value || is_convertible<U*,T*>::value, bool>::type
is_same_object (
        const T& a,
        const U& b
)
{
    return ((void*)&a == (void*)&b);
}

template < typename T, typename U >
typename enable_if_c<is_convertible<T*, U*>::value || is_convertible<U*,T*>::value, bool>::type
is_same_object (
        const T& a,
        const U& b
)
{
    return (&a == &b);
}

template <typename T> struct is_built_in_scalar_type        { const static bool value = false; };
template <> struct is_built_in_scalar_type<float>           { const static bool value = true; };
template <> struct is_built_in_scalar_type<double>          { const static bool value = true; };
template <> struct is_built_in_scalar_type<long double>     { const static bool value = true; };
template <> struct is_built_in_scalar_type<short>           { const static bool value = true; };
template <> struct is_built_in_scalar_type<int>             { const static bool value = true; };

template <typename T> inline typename disable_if<is_built_in_scalar_type<T>,void>::type assign_zero_if_built_in_scalar_type (T&){}
template <typename T> inline typename enable_if<is_built_in_scalar_type<T>,void>::type assign_zero_if_built_in_scalar_type (T& a){a=0;}

int main()
{
    int i = 1;
    std::cout << is_same_object<int, int>(i,i) <<std::endl; //true
    std::cout << is_same_object<long, int>(1,2) <<std::endl; //false
    std::cout << is_same_object<int, int>(1,1) <<std::endl; //false

    int i=1;
    assign_zero_if_built_in_scalar_type<int>(i);
    std::cout << i <<std::endl; //0
    char c = '1';
    assign_zero_if_built_in_scalar_type<char>(c);
    std::cout << c <<std::endl;  //1
}