Is it possible in c++ to define a type depending on a constant value, without using #defines

Question

I need to define a "Float" type, depending on the compilation constant defining the size of the "Int" type. That constant let's call it "IntBits" may be 32, 64, 128 etc. (could be also in between 40, 48 etc). So the Float should be accordingly defined as: __float32 __float64 __float128 etc. Essentially I need to define "Float" as __float32 when IntBits<=32 as Float64 if IntBits<=64 etc.

Is there a way to avoid to use #define 's ?

Answer 1

You might use:

• std::conditional

  template <std::size_t N>
  using Float = std::conditional_t<N <= 32, float,
                std::conditional_t<N <= 64, double,
                                            long double>>;
  

• or partial specialization (example uses C++20):

  template <std::size_t N>
  struct FloatSelector
  {
      using type = long double;
  }
  
  template <std::size_t N>
  requires (N <= 32)
  struct FloatSelector
  {
      using type = float;
  };
  
  template <std::size_t N>
  requires (32 < N && N <= 64)
  struct FloatSelector
  {
      using type = double;
  };
  
  template <std::size_t N>
  using Float = typename FloatSelector<N>::type;
  

Answer 2

Here’s a runnable snippet that resolves a type called Int (based on its size) to a std::float…_t of equal size, at compile time:

#include <cstdint>
#include <iostream>
#include <stdfloat>

namespace {

template <std::size_t> struct Mapping;
template <> struct Mapping<2> { using Float = std::float16_t; };
template <> struct Mapping<4> { using Float = std::float32_t; };
template <> struct Mapping<8> { using Float = std::float64_t; };
template <> struct Mapping<16> { using Float = std::float128_t; };

template <typename Type>
struct Trait { using Float = Mapping<sizeof(Type)>::Float; };

}  // namespace

int main() {
  { using Int = std::int16_t;
    using Float = Trait<Int>::Float;
    std::cout << sizeof(Float) << std::endl; }
  { using Int = std::int32_t;
    using Float = Trait<Int>::Float;
    std::cout << sizeof(Float) << std::endl; }
  { using Int = std::int64_t;
    using Float = Trait<Int>::Float;
    std::cout << sizeof(Float) << std::endl; }
  { using Int = std::int8_t[16];  // no std::int128_t available yet
    using Float = Trait<Int>::Float;
    std::cout << sizeof(Float) << std::endl; }
}

Admittedly, the need for Mapping is unpleasant, but OTOH, the number of available floating-point types is not way too high or arbitrary.

There are numerous other ways to express the same thing using templates or if constexpr constructs. Also, there are (not very portable) 80-bit and other compiler-specific floating-point type aliases. Some of those aliases can be used in case C++23 and <stdfloat> is not supported yet. (At the time of this writing, g++ has <stdfloat> available, but clang++ does not.)

Answer 3

Given the support of previous answers I finally finalized the code as follows:

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdint>
#include <type_traits> // for std::conditional

using namespace std;
template <size_t N> using Float_4=conditional< 80<N && N<=128, _Float128,bool>::type;
template <size_t N> using Float_3=conditional< 64<N && N<= 80,__float80 ,Float_4<N>>::type;
template <size_t N> using Float_2=conditional< 32<N && N<= 64, _Float64 ,Float_3<N>>::type;
template <size_t N> using Float_1=conditional< 16<N && N<= 32, _Float32 ,Float_2<N>>::type;
template <size_t N> using Float_0=conditional<  0<N && N<= 16, _Float16 ,Float_1<N>>::type;

typedef Float_0<81> Float;

int main(int argc, char **argv)
{
    Float x=12.3456789012345678901234567890123456789e-3L;
    std::cout<<"Hello x="<<setw(50)<<setprecision(40)<<x<<std::endl;
    return 0;
}

Unfortunately the code above while should work for N=15 and N=89 etc, it does not work for all cases because << is still "under development" for types as _Float16 or _Float128 :-) .