C++ 浮动的模板专门化

我知道，我不能在模板中使用float作为非类型参数。所以我想用分子和分母来表示极限类

我的limit类获取一个类型以及最小值和最大值。要对int和float使用Limit，我当前使用：

template <typename U, typename T = U, T A1 = 0, T A2 = 0, T A3 = 0, T A4 = 0>
struct Limit {
  static constexpr const U min = A1;
  static constexpr const U max = A2;
};

template <intmax_t A1, intmax_t A2, intmax_t A3, intmax_t A4>
struct Limit<float, intmax_t, A1, A2, A3, A4>  {
  static constexpr const float min = A1 / (float) A2;
  static constexpr const float max = A3 / (float) A4;
};

Limit<float, intmax_t, 40, 20, 30, 40> a;

Limit<int, 10, 20> b;

模板
结构极限{
静态常数expr const U min=A1；
静态常数expr常数U max=A2；
};
模板
结构极限{
静态常数表达式常数浮点最小值=A1/（浮点）A2；
静态常数表达式常数浮点最大值=A3/（浮点）A4；
};
限制a；
极限b；

有没有办法优化这个实现？并且可能为浮点实现启用默认值

提前谢谢你

编辑：我希望有一个这样的模板声明（不起作用）：

//对于int、char、short、uint32\u t等。。。
模板
结构极限{
静态常数expr const U min=min；
静态常数expr const U max=max；
};
//浮球/双球
模板
结构极限{
静态constexpr const T min=min.num/（T）min.dem；//静态强制转换。。。
静态constexpr const T max=max.num/（T）max.dem；//静态强制转换。。。
};
限制a；
极限b；

我认为您的实现需要使用。您可以为

min

和

max

使用两个原始

std:：ratio

，或者使用如下实现：

template<typename U, std::intmax_t NumerMin = 0, std::intmax_t DenomMin = 1,
                     std::intmax_t NumerMax = 0, std::intmax_t DenomMax = 1>
struct Limit {
  static const std::ratio<NumerMin, DenomMin> min_;
  static const std::ratio<NumerMax, DenomMax> max_;
public:
  U const min = static_cast<U>(min_.num) / static_cast<U>(min_.den);
  U const max = static_cast<U>(max_.num) / static_cast<U>(max_.den);
};

模板
结构极限{
静态常数标准：：比率最小值；
静态常数标准：：比率最大值；
公众：
最小常数=静态施法（最小值）/静态施法（最小值）；
U const max=静态施法（max.num）/静态施法（max.den）；
};

---

您可以始终将其包装为

比率

s，以便编写

限制

或者你也可以按照

// if T is floating point, return std::intmax_t, otherwise T.
template<class T>
using adjust_floating = std::conditional_t<std::is_floating_point<T>{}, std::intmax_t, T>;

template <class T, adjust_floating<T> A1 = 0,
                   adjust_floating<T> A2 = 0,
                   adjust_floating<T> A3 = 0,
                   adjust_floating<T> A4 = 0 >
struct Limit {
    // maybe static_assert that A3 and A4 are zero if T isn't floating point
    static constexpr T min = std::is_floating_point<T>{} ? A1 / (T) A2 : A1;
    static constexpr T max = std::is_floating_point<T>{} ? A3 / (T) A4 : A2;
};

//如果T是浮点，则返回std:：intmax\u T，否则返回T。
模板
使用adjust\u floating=std:：conditional\u t；
模板
结构极限{
//如果T不是浮点，那么静态_可能断言A3和A4为零
静态constexpr T min=std:：is_浮点{}？A1/（T）A2:A1；
静态constexpr T max=std:：is_浮点{}？A3/（T）A4:A2；
};

关于这些值范围的一些信息可能会有所帮助。您的另一个选项是通过使用指数而不是分母来“模拟”浮点值-对于两个限制（因此对范围的请求）可能是相同的，您的当前代码不会编译（

g++5.3.0

），因为

Limit

不是有效的实例化（第二个参数必须是类型）。如果你使用这种方法，你必须创建另一个专门化。定义“优化”。定义“不工作”。谢谢。比率是一个选项，但如果我有Num和Denom，我不需要定义额外的比率，我想。。。。对于我必须定义的int值：Limit，请参阅我的更新。

// if T is floating point, return std::intmax_t, otherwise T.
template<class T>
using adjust_floating = std::conditional_t<std::is_floating_point<T>{}, std::intmax_t, T>;

template <class T, adjust_floating<T> A1 = 0,
                   adjust_floating<T> A2 = 0,
                   adjust_floating<T> A3 = 0,
                   adjust_floating<T> A4 = 0 >
struct Limit {
    // maybe static_assert that A3 and A4 are zero if T isn't floating point
    static constexpr T min = std::is_floating_point<T>{} ? A1 / (T) A2 : A1;
    static constexpr T max = std::is_floating_point<T>{} ? A3 / (T) A4 : A2;
};