是否可以通过模板类型更改静态const类成员的值？

Question

I don't really know the terminology on this, I'll just do an example:

template <typename T>
struct value_holder {
    T value;
    static const bool is_integer = ??; // if T is int or long set this to true, else set false
}

so that when I do

value_holder<float> floaty;
std::cout << floaty.is_integer << "\n";

it would print 0

How would I have to define the member is_integer so it would do that?

Answer 1

You can use std::is_same to do that.
It follows a minimal, working example:

#include<type_traits>

template <typename T>
struct value_holder {
    T value;
    static const bool is_integer = std::is_same<int, T>::value or std::is_same<long, T>::value;
};

int main() {
    static_assert(value_holder<int>::is_integer, "!");
    static_assert(not value_holder<char>::is_integer, "!");
}

Another possible approach is based on template specialization. Something along this way should work:

template <typename T>
struct value_holder {
    T value;
    static const bool is_integer = false;
};

template <>
struct value_holder<int> {
    int value;
    static const bool is_integer = true;
};

template <>
struct value_holder<long> {
    long value;
    static const bool is_integer = true;
};

Anyway it's a bit more verbose from my point of view and can be annoying if your class contains more than a couple data members.

Answer 2

As Quentin's answer says, you use a type trait. std::is_integral makes sense in your example:

template <typename T>
struct value_holder {
    T value;
    static constexpr bool is_integer = std::is_integral<T>::value;
};

That doesn't exactly match your comment though. If you really want to have is_integer be true only for int or long then you could define a custom type trait:

template <typename T>
struct is_int_or_long : std::false_type {};

template <>
struct is_int_or_long<int> : std::true_type {};

template <>
struct is_int_or_long<long> : std::true_type {};

template <typename T>
struct value_holder {
    T value;
    static constexpr bool is_integer = is_int_or_long<T>::value;
};

Of course, that could be shortened by using the std::is_same trait:

template <typename T>
struct value_holder {
    T value;
    static constexpr bool is_integer = std::is_same<T, int>::value || std::is_same<T, long>::value;
};

Answer 3

You're looking for type traits . std::is_integral might be of interest to you.