Thread: Class template that specializes- and accepts only integer and floating point types

I'm trying to create a class that works with integral and floating point types, but rejects any others. I got the following to work, where the generic template gets rejected using static_assert:

Code:

#include <iostream>
#include <type_traits>
#include <utility>

using namespace std;

template<typename T, typename Enable = void>
class X
{
static_assert(is_arithmetic_v<T>,
              "X must be instantiated with integral or floating-point template argument.");
};

template<typename T>
class X<T, enable_if_t<is_integral_v<T>>>
{
public:
    X() { cout << "X<integral type>()" << endl; }
};

template<typename T>
class X<T, enable_if_t<is_floating_point_v<T>>>
{
public:
    X() { cout << "X<float type>()" << endl; }
};

class P {};

int main()
{
    X<long> x1;
    X<double> x2;
    X<P> x3; // prevented by failing static assertion
}

Is there a way to only use two class templates for this scenario, making the generic version redundant?

I may be wrong but I don't think so.

You have the top-level generic version and assuming that each specialization has its own unique behavior, I think you need the generic one.

If you can treat both floating and integral versions the same way, you can probably just use only one template which is templated std::enable_if_t<std::is_arithmetic_v<T>>

Hmm.. Out of curiosity, what happens if you comment out your top-level class and only leave two specializations there?

double can perfectly contain anything long can on any 32 bit and even on some 64 bit platforms. I don't know what you plan on using X for, but depending on its use case, keep in mind that you might be better off using the most encompassing type and forgo templating.