template < class T > class C
{
public:
    C (T* t) {};
};

struct S
{
    int _internal;
};

S* CreateS()
{
    return new S();
}

typedef S* PS;

int main()
{
    PS p = CreateS();

    // Как получается
    C < S > c1(p);

    // Как хотелось бы, но не получается:
    C < *PS > c2(p);
    // Или что-то подобное.
}

struct RegKeyDeleter
{
  using pointer = HKEY;
  void operator()(pointer p) const
  { 
     RegCloseKey(p);
  }
};

using unique_reg_key = std::unique_ptr<HKEY, RegKeyDeleter>;

G>struct RegKeyDeleter
G>{
G>  using pointer = HKEY;
G>  void operator()(pointer p) const
G>  { 
G>     RegCloseKey(p);
G>  }
G>};

G>using unique_reg_key = std::unique_ptr<HKEY, RegKeyDeleter>;
G>

struct RegKeyDeleter
{
    //using pointer = HKEY;
    void operator()(HKEY p) const
    {
        RegCloseKey(p);
    }
};

using unique_reg_key = std::unique_ptr<HKEY, RegKeyDeleter>;

LK>struct RegKeyDeleter
LK>{
LK>    //using pointer = HKEY;
LK>    void operator()(HKEY p) const
LK>    {
LK>        RegCloseKey(p);
LK>    }
LK>};

LK>using unique_reg_key = std::unique_ptr<HKEY, RegKeyDeleter>;
LK>

class RegKey {
public:
  RegKey() {}
  explicit RegKey(HKEY h) : h_(h) {}
  RegKey(RegKey&& r) { r.swap(*this); }

  ~RegKey() { if (h_ != INVALID_HANDLE_VALUE) ::RegCloseKey(h_); }

  RegKey& operator = (HKEY h) { return *this = RegKey(h); }
  RegKey& operator = (RegKey&& r) { r.swap(*this); return *this; }

  void swap(RegKey& r) { swap(h_, r.h_); }

  HKEY detach() { HKEY h = h_; h_ = INVALID_HANDLE_VALUE; return h; }
  HKEY get() const { return h_; }
  // operator * и -> смысла не имеют, т.к. HKEY не разыменуемый

  operator bool() const { return h_ != INVALID_HANDLE_VALUE; }

private:
  HKEY h_ = INVALID_HANDLE_VALUE;
};

template <typename, typename = void>
struct MySpecialRemovePointer;

template <typename T>
struct MySpecialRemovePointer<T, std::enable_if_t<std::is_pointer<T>::value>> : std::remove_pointer<T> {};

template <typename T>
using MySpecialRemovePointer = std::enable_if<std::is_pointer<T>::value, std::remove_pointer_t<T>>;