Есть идея сделать как-нибудь так:

template<typename T, typename TFloatValueStruct>
class X
{
 bool b;
public:
 X(T t)
 {
  b = t==TFloatValueStruct::value;
 }
};

А TFloatValueStruct описать как-нибудь так:

struct MyFloatValue
{ static const float value; }
const float MyFloatValue::value = 10.1;

X<float,MyFloatValue> x;

Неудобство заключается в том что нужно создавать дополнительный класс.

Можно разбить число на составляющие, которые будут целыми, и тогда можно будет обходиться одним вспомогательным классом.

Вроде такого :

X<float,
  float_value_wrapper<false, // +
      10,0, // 10*10^0
      1,1 // 1/10^1
  >
> x; // + (10*10^0 + 1/10^1) = + 10.1

Примерная реализация

template<typename T,
         bool t_t_bminus,
         size_t t_n1,
         int t_pow1,
         size_t t_n2,
         int t_pow2
        >
struct nonintegral_value_wrapper
{
 static const T value;
};

template<typename T,
         bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
const T nonintegral_value_wrapper<T,t_bminus,t_n1,t_pow1,t_n2,t_pow2>::value =
 (
  static_cast<T>(t_n1) * static_cast<T>(pow10_t<t_pow1>::value)  // t_n1*(10^t_pow1) - целая часть
  +
  static_cast<T>(t_n2) / static_cast<T>(pow10_t<t_pow2>::value)  // t_n2/(10"t_pow2) - дробная часть
 )
 *
 (t_bminus?static_cast<T>(-1):static_cast<T>(+1)); // отрицательное или положительное число

// для float
template<bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
struct float_value_wrapper :
 public nonintegral_value_wrapper
 <
  float,
  t_bminus,
  t_n1,
  t_pow1,
  t_n2,
  t_pow2
 >
{};

// для double
template<bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
struct double_value_wrapper :
 public nonintegral_value_wrapper
 <
  double,
  t_bminus,
  t_n1,
  t_pow1,
  t_n2,
  t_pow2
 >
{};

Буду рад комментариям.