A template-argument for a non-type, non-template template-parameter shall be one of:
— an integral constant-expression of integral or enumeration type; or
— the name of a non-type template-parameter; or
— the name of an object or function with external linkage, including function templates and function
template-ids but excluding non-static class members, expressed as id-expression; or
— the address of an object or function with external linkage, including function templates and function
template-ids but excluding non-static class members, expressed as & id-expression where the & is
optional if the name refers to a function or array; or
— a pointer to member expressed as described in 5.3.1.

DOB>template<void *V> class T {};
DOB>T<(void *)1> t; // <- здесь

template<void *V> class T {};

extern X x;

T<&x> t;

DOB>template<void *V> class T {};
DOB>T<(void *)1> t; // <- здесь

template<int n> class T {};
T<1> t;

test.cpp:2: `0' is not a valid template argument
test.cpp:2: it must be the address of an object with external linkage

template<BOOL (WINAPI *Clo)(HANDLE), HANDLE Inv> class handle_t {
    HANDLE    _h;
public:
    handle_t(): _h(Inv) {}
    // ...
    virtual ~handle_t() { close(); }

    handle_t &operator = (HANDLE h)
    {
        close(); _h = h;
    }
 
    operator HANDLE() const { return _h; }

    void close()
    {
        if( Inv != _h ) {
            Clo( _h );
            _h = Inv;
        }
    }
};
typedef handle_t<CloseHandle, INVALID_HANDLE_VALUE> file_handle_t;
typedef handle_t<CloseHandle, NULL> event_handle_t;
typedef handle_t<FindClose, INVALID_HANDLE_VALUE> notif_handle_t;
//...

 do> template<BOOL (WINAPI *Clo)(HANDLE), HANDLE Inv> class handle_t {
 do>  HANDLE _h;
 do> public:
 do>  handle_t(): _h(Inv) {}
 do>  // ...

 do>  void close()
 do>  {
 do>   if( Inv != _h ) {
 do>    Clo( _h );
 do>    _h = Inv;
 do>   }
 do>  }
 do> };
 do> typedef handle_t<CloseHandle, INVALID_HANDLE_VALUE> file_handle_t;
 do> typedef handle_t<CloseHandle, NULL> event_handle_t;
 do> typedef handle_t<FindClose, INVALID_HANDLE_VALUE> notif_handle_t;
 do> //...
 do>

struct InvalidHandleValue
{
  static HANDLE inv() { return INVALID_HANDLE_VALUE; }
};

struct NullHandle
{
  static HANDLE inv() { return NULL; }
};

template<BOOL (WINAPI *Clo)(HANDLE), class InvPolicy>
class handle_t {
 HANDLE _h;
public:
 handle_t(): _h(InvPolicy::inv()) {}
 // ...
};

template<class Policy>
class handle_t {
  . . .

struct NULL_st 
{ 
static HANDLE get_invalid() { return NULL; } 
};

struct INV_HANDLE_st 
{ 
static HANDLE get_invalid() { return INVALID_HANDLE_VALUE; } 
};

template<BOOL (WINAPI *Clo)(HANDLE), class T Inv> class handle_t {
    HANDLE    _h;
public:
    handle_t() {}
    // ...
    virtual ~handle_t() { close(); }

    handle_t &operator = (HANDLE h)
    {
        close(); _h = h;
    }
 
    operator HANDLE() const { return _h; }

    void close()
    {
        if( Inv::get_invalid() != _h ) {
            Clo( _h );
            _h = Inv::get_invalid();
        }
    }
};
typedef handle_t<CloseHandle, INV_HANDLE_st> file_handle_t;
typedef handle_t<CloseHandle, NULL_st> event_handle_t;
typedef handle_t<FindClose, INV_HANDLE_st> notif_handle_t;