has_const_reference_op, C++ (vc++)

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x86

#include <iostream>
#include <type_traits>

template< typename T > struct is_const_dereferencible
{
    template< typename U > static
    std::true_type test( const U&& u, typename std::remove_reference< decltype( *u ) >::type* = nullptr ) ;

static std::false_type test(...) ;

using type = decltype( test( std::declval< typename std::decay<T>::type >() ) ) ;
	static constexpr bool value = type::value ;
};

template< typename T, typename = void >
struct const_dereferenced_type { struct nothing ; using type = nothing ; using base_type = nothing ; } ;

template< typename T >
struct const_dereferenced_type< T, typename std::enable_if< is_const_dereferencible<T>::value >::type >
{
    using type = decltype( *std::declval< typename std::add_const< typename std::decay<T>::type >::type >() ) ;
    using base_type = typename std::decay<type>::type ;
};

template< typename T, typename E > struct has_const_reference_op :
                    std::conditional< is_const_dereferencible<T>::value &&
                                      std::is_same< typename const_dereferenced_type<T>::type, E >::value,
                                      std::true_type, std::false_type >::type {};

int main()
{
    struct A { int operator* () const  { return 0 ; } double operator* () { return 0 ; } };
    std::cout << std::boolalpha << has_const_reference_op< A, int >::value << '\n' // true
              << has_const_reference_op< A, double >::value << '\n' // false
              << is_const_dereferencible<A>::value << '\n' // true
              << std::is_same< const_dereferenced_type<A>::type, int >::value << '\n' // true
              << std::is_same< const_dereferenced_type<A>::type, double >::value << "\n\n" ; // false

struct B { int operator* () { return 0 ; } };
    std::cout << has_const_reference_op< B, int >::value << '\n' // false
              << std::boolalpha << is_const_dereferencible<B>::value << '\n' // false
              << std::is_same< const_dereferenced_type<B>::type, int >::value << "\n\n" ; // false

std::cout << std::boolalpha << has_const_reference_op< int*, int& >::value << '\n' // true
              << is_const_dereferencible< int* >::value << '\n' // true
              << std::is_same< const_dereferenced_type<int*>::type, int& >::value << '\n' // true
              << std::is_same< const_dereferenced_type<int*>::type, int >::value << '\n' // false
              << std::is_same< const_dereferenced_type<int*>::base_type, int >::value << "\n\n" ; // true

std::cout << std::boolalpha << has_const_reference_op< const int*, const int& >::value << '\n' // true
              << is_const_dereferencible< const int* >::value << '\n' // true
              << std::is_same< const_dereferenced_type< const int* >::type, const int& >::value << '\n' // true
              << std::is_same< const_dereferenced_type< const int* >::base_type, int >::value << '\n' // true
              << std::is_same< const_dereferenced_type< const int* >::type, int& >::value << "\n\n" ; // false
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,9 sec, absolute running time: 0,32 sec, absolute service time: 2,24 sec