在C ++中过滤类型名称

Question

This is my converter to byte array (vector).

template<typename T>
void put(T value) {
    int size = sizeof(value);

    uint8_t *array;
    array = reinterpret_cast<uint8_t *>(&value);

    if (littleEndian) {
        for (int i = 0; i < size; i++) {
            arr.push_back(array[i]);
        }
    } else {
        for (int i = size - 1; i >= 0; i--) {
            arr.push_back(array[i]);
        }
    }
}

As you can see, this function accepts all variable types. Is it possible to filter typenames? Eg I want to allow only uint8_t, int8_t, uint16_t, int16_t etc. + float and double too ? I don't want to make 10 if statements, because it doesn't look clean.

Answer 1

You can do this using std::is_integral and SFINAE. This will remove the template from consideration if the type is not a integer type. It would look something like

template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void put(T value)
{
    // code
}

Live Example

If instead you want allow all integral and floating point types then you can use std::is_arithmetic like

template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
void put(T value)
{
    // code
}

Answer 2

It seems you need a function that accept only any integral types.

There is an existing type trait for that un the <type_traits> header called std::is_integral . You can use it with std::enable_if to produce the expected constraint:

template<typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
void put(T value) {
    constexpr int size = sizeof(value);

    uint8_t *array;
    array = reinterpret_cast<uint8_t *>(&value);

    if (littleEndian) {
        for (int i = 0; i < size; i++) {
            arr.push_back(array[i]);
        }
    } else {
        for (int i = size - 1; i >= 0; i--) {
            arr.push_back(array[i]);
        }
    }
}

Your function is now not callable with non integral types.

Be aware that if there's another overload of the function, the compiler will try it too. That means that if you have another function that accept any floating types, the compiler will select the appropriated overload.