How to produce compiler error if default template is used? - c++

Question

Using template specialization, I've written a series of functions all having the same name and taking the same argument type, but returning data of the type specified by the template parameter:
template<typename T> T f (int x); // Purposefully unimplemented.
template<> inline uint8_t f<uint8_t> (int x) { return f8 [x]; }
template<> inline uint16_t f<uint16_t>(int x) { return f16 [x]; }
template<> inline uint32_t f<uint32_t>(int x) { return f32 [x]; }
template<> inline uint64_t f<uint64_t>(int x) { return f64 [x]; }
Then I can write code like:
uint32_t a = f<uint32_t>(3);
uint64_t b = f<uint64_t>(7);
I've purposefully left the default template unimplemented to produce a linker error if someone tries to use a version of f for anything other than the specialized types for which I've defined it.
I have two questions:
1) Is there some way I can use static_assert() (or whatever) to produce a compile error (instead of a linker error) if someone tries to use the default template that's more friendly than what I get now: undefined reference to `int f(int)'?
2) Is there some way to do this with templates that maintains the same interface to the programmer, but doesn't require template specialization? (I.e., is there some way to avoid a default template altogether?)

Answer 1

namespace fimpl{
template<class T>struct tag_t{};
template<class T>
void fimpl(tag_t<T>, int x)=delete;
}
template<typename T> T f (int x){ using fimpl::fimpl; return fimpl(fimpl::tag_t<T>{}, x); }
now don't specialize; override.
namespace fimpl{ inline uint8_t fimpl(tag_t<uint8_t>, int x) { return f8 [x]; } }
namespace fimpl{ inline uint16_t fimpl(tag_t<uint16_t>, int x) { return f16 [x]; } }
namespace fimpl{ inline uint32_t fimpl(tag_t<uint32_t>, int x) { return f32 [x]; } }
namespace fimpl{ inline uint64_t fimpl(tag_t<uint64_t>, int x) { return f64 [x]; } }
This uses tag dispatching to pick which override instead of using specialization.
If no explicit specialization is found, the =delete template is picked and youmget a compiler error immediately.
Amusingly, if you wanted to extend this with new types, say namespace lib{ struct bigint; } you can put a fimpl(fimpl::tag_t<bigint>, int) overload in namespace lib and it would work. I doubt you'll need that.
You can also do away with f as a template if you are ok with f(tag<uint8_t>, 7) instead of f<uint8_t>(7). Just get rid of fimpl namespace (moving stuff out of it), rename fimpl::fimpl to just f, remove =deleteed template function, add template<class T> constexpr tag_t<T> tag{};. But the syntax is a bit different at point of call.

Answer 2

Is there some way I can use static_assert (or whatever) to produce a compile error (instead of a linker error) if someone tries to use the default template that's more friendly than what I get now: undefined reference to `int f(int)'?
I think the better solution is the one suggested by Passer By in a comment:
template<typename T> T f (int x) = delete;
But if you really want to use a static_assert()... I suppose you can try something as follows
template<typename T>
T f (int x)
{
static_assert( sizeof(T) == std::size_t(-1), "f()!" );
return {};
}
Is there some way to do this with templates that maintains the same interface to the programmer, but doesn't require template specialization? (I.e., is there some way to avoid a default template altogether?)
Isn't clear to me what do exactly want.
You don't want specialization and you want avoid default template?
Supposing that you want only the default template that is available only for a specific set of types, I suppose you can use SFINAE.
To make an example, the following f() is enabled only if T is an integral type.
template<typename T>
typename std::enable_if<std::is_integral<T>{}, T>::type f (int x)
{ return x; }
The following is a full compiling example
#include <iostream>
#include <type_traits>
template<typename T>
typename std::enable_if<std::is_integral<T>{}, T>::type f (int x)
{ return x; }
int main ()
{
auto f16 = f<std::uint16_t>(0);
auto f32 = f<std::uint32_t>(0);
static_assert( std::is_same<decltype(f16), std::uint16_t>{}, "!" );
static_assert( std::is_same<decltype(f32), std::uint32_t>{}, "!" );
// compilation error
// auto fd = f<double>(0);
}