When is deleting a template instantiation preferable to deleting a non-template overload?

Question

Suppose I have a template that works with raw pointers:

template<typename T> void processPointer(T* ptr); 

I don't want this to be called with void* pointers. It seems I have two choices. I can delete a non-template overload:

void processPointer(void*) = delete; 

Or I can delete a template instantiation:

template<> void processPointer<void>(void*) = delete; 

Declaring the non-template overload is easier (no futzing with angle brackets). Are there reasons why I'd prefer to delete the template instantiation instead?

Answer 1

Here's one reason to favor the template version: processPointer<void>(void*) can still be invoked directly, avoiding the other overload.

Answer 2

I don't see any reason to go templating here

In fact, by deleting the non-template overload you may wiggle your way out of some edge-case ambiguous calls that I can't think of right now, since non-templates take precedence over template instantiations. And thus make this work as desired in a majority of cases.