trivial implementation of a basic hash pointer

hash_ptr.h

template<typename T, typename Hasher = ::std::hash<T>>
class hash_ptr {
public:
  using value_type = T;
  using reference = std::add_lvalue_reference_t<value_type>;
  using const_reference = const value_type &;
  using pointer = T*;
  using hash_type = typename Hasher::result_type;
  //using hash_type = typename decltype( std::declval<Hasher>( )( std::declval<value_type>( ) ) );
  
  hash_ptr( pointer ptr, Hasher hasher = Hasher{} ) 
    : m_p( std::forward<pointer>( ptr ) )
    , m_hash( hasher( *ptr ) ) { }
  
  reference operator*( ) { return *m_p; }
  const_reference operator*( ) const { return *m_p; }
  pointer operator->( ) {
    return m_p;
  }
  bool good( ) const {
    return m_p != nullptr && m_hash == Hasher{}( *m_p );
  }

  operator bool( ) const {
    return good( );
  }
  operator pointer( ) const {
    return m_p;
  }

  hash_type hash( ) const { return m_hash; }
private:
  pointer m_p;
  hash_type m_hash;
};