Merged, thanks!

why 4 overloads instead of 1 overload taking a const volatile void*?

why 4 overloads instead of 1 overload taking a const volatile void*?

It's a good question.

If all we had was 4 overloaded functions (void*, const void*, volatile void*, const volatile void*), I believe your suggestion would be fine.

However, there's also this:

as we only want to format (const)? (volatile)? void pointers, so this catches other pointer types to render them unformattable.

If we remove the first 3 of those, leaving only the const volatile void* overload, and we pass a void* - which should be formattable - the compiler will no longer find a function with a parameter that is an exact match.

It will then go and instantiate the unformattable function template above as the next best match. Our const volatile void* overload is lower precedence as it involves a conversion, and the function template just binds a const ref (is my understanding), which is not what we want.

See https://godbolt.org/z/3cTj5xErM and flip the define

You could probably get this working with some SFINAE (although I think you'll have a similar issue with getting int* to be unformattable still so you'll need another SFINAE function), but IMO overloading is generally simpler and easier to reason about, so preferred here

@Arghnews

making the SFINAE condition

std::is_pointer<T>::value && !std::is_void<typename std::remove_pointer<T>::type>::value

will work.

I agree that overloading is easier to reason about. but I just wanted to point it out.

@ZXShady Good point, the SFINAE isn't so bad actually.
We agree to prefer the overloads regardless.

Also I've learnt something from your comment, as I didn't know realise that all types of void* can bind to const volatile void*, so thank you