<QtNumeric> - Qt 数值函数

函数文档

对一个浮点值进行分类。

返回值在 <cmath> 中定义：根据 val 的浮点类别返回以下之一

• FP_NAN 不是数字
• FP_INFINITE 无限大（正或负）
• FP_ZERO 零（正或负）
• FP_NORMAL 带有完整尾数的有限值
• FP_SUBNORMAL 带有缩减尾数的有限值

[constexpr] template <typename T> T qAbs(const T &t)

将类型为 T 的 t 与 0 进行比较，并返回绝对值。因此，如果 T 是 double 类型，那么 t 将与 (double) 0 进行比较。

示例

int absoluteValue;
int myValue = -4;

absoluteValue = qAbs(myValue);
// absoluteValue == 4

[自 6.1 版起] 模板 <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qAddOverflow(T v1, T v2, T *result)

将两个数值 v1 和 v2（数值类型 T）相加，并将结果记录在 result 中。如果加法结果超出类型 T 的有效范围，则返回 true，否则返回 false。

保证实现可供 8 位、16 位和 32 位整数类型以及指针尺寸的整数类型使用。对于其他类型的溢出数学（如果有的话），被认为是私有 API。

此函数在 Qt 6.1 中引入。

quint32 qFloatDistance(float a, float b)

返回在 a 和 b 之间的可表示浮点数的数量。

此函数提供了类似 qFuzzyCompare 的浮点数近似比较的另一种方法。然而，它返回两个数字之间的距离，这允许调用者选择可接受的误差。误差是相对的，例如，1.0E-5 和 1.00001E-5 之间的距离将为 110，而 1.0E36 和 1.00001E36 之间的距离将为 127。

此函数在需要一定精度的浮点数比较时很有用。因此，如果 a 和 b 相等，它将返回 0。对于 32 位浮点数，它将返回的最大值是 4,278,190,078。这是 -FLT_MAX 和 +FLT_MAX 之间的距离。

如果任何参数是 Infinite 或 NaN，则该函数给出的结果没有意义。您可以通过调用 qIsFinite 来检查此情况。

返回值可以被视为“误差”，因此，如果您想比较两个 32 位浮点数并且所需的仅是 24 位近似的精度，则可以使用此函数如下：

    if (qFloatDistance(a, b) < (1 << 7)) {   // The last 7 bits are not
                                            // significant
        // precise enough
    }

另请参阅qFuzzyCompare。

quint64 qFloatDistance(double a, double b)

返回在 a 和 b 之间的可表示浮点数的数量。

此函数与 qFloatDistance(float, float) 具有相同的目的，但返回两个 double 数字之间的距离。由于范围大于两个 float 数字（[-DBL_MAX,DBL_MAX]），返回类型是 quint64。

另请参阅qFuzzyCompare。

int qFpClassify(double val)

int qFpClassify(float val)

[ constexpr ] bool qFuzzyCompare(double p1, double )

比较浮点值 p1 和 p2，如果它们被认为是相等的，则返回 true，否则返回 false。

请注意，当 p1 或 p2 之一是 0.0 时，比较值将不起作用，当比较的值之一是 NaN 或无限大时也是如此。如果一个值总是 0.0，请使用 qFuzzyIsNull。如果一个值可能为 0.0，一个解决方案是向两个值都加 1.0。

// Instead of comparing with 0.0
qFuzzyCompare(0.0, 1.0e-200); // This will return false
// Compare adding 1 to both values will fix the problem
qFuzzyCompare(1 + 0.0, 1 + 1.0e-200); // This will return true

这两个数字按照相对方式进行比较，其中精确度越强，数字越小。

注意：此函数是线程安全的。

[constexpr] bool qFuzzyCompare(float p1, float p2)

比较浮点值 p1 和 p2，如果它们被认为是相等的，则返回 true，否则返回 false。

这两个数字按照相对方式进行比较，其中精确度越强，数字越小。

注意：此函数是线程安全的。

[constexpr] bool qFuzzyIsNull(double d)

如果 d 的绝对值在 0.000000000001 以内，则返回 true。

注意：此函数是线程安全的。

[constexpr] bool qFuzzyIsNull(float f)

如果 f 的绝对值在 0.00001f 以内，则返回 true。

注意：此函数是线程安全的。

double qInf()

返回作为 double 的无穷数的位模式。

另请参阅：qIsInf()

bool qIsFinite(double d)

如果 double d 是有限数，则返回 true。

bool qIsFinite(float f)

如果 float f 是有限数，则返回 true。

bool qIsInf(double d)

如果 double d 等价于无穷大，则返回 true。

另请参阅：qInf()

bool qIsInf(float f)

如果 float f 等价于无穷大，则返回 true。

另请参阅：qInf()

bool qIsNaN(double d)

如果 double d 不是数字（NaN），则返回 true。

bool qIsNaN(float f)

如果 float f 不是数字（NaN），则返回 true。

[since 6.1] 模板 <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qMulOverflow(T v1, T v2, T *result)

将 v1 和 v2 相乘，并将结果值记录在 result 中。如果乘法超出类型 T 的有效范围，则返回 true，否则返回 false。

保证实现可供 8 位、16 位和 32 位整数类型以及指针尺寸的整数类型使用。对于其他类型的溢出数学（如果有的话），被认为是私有 API。

此函数在 Qt 6.1 中引入。

double qQNaN()

返回一个静默 NaN 的位模式作为 double。

另请参阅：qIsNaN()

[constexpr] qint64 qRound64(double d)

将 d 四舍五入到最接近的 64 位整数。

四舍六入五取偶（例如，0.5 -> 1，-0.5 -> -1)。

示例

double valueA = 42949672960.3;
double valueB = 42949672960.7;

qint64 roundedValueA = qRound64(valueA);
// roundedValueA = 42949672960
qint64 roundedValueB = qRound64(valueB);
// roundedValueB = 42949672961

[constexpr] qint64 qRound64(float d)

将 d 四舍五入到最接近的 64 位整数。

将数值四舍五入到最近的整数（例如 0.5f 变为 1，-0.5f 变为 -1）。

示例

float valueA = 42949672960.3;
float valueB = 42949672960.7;

qint64 roundedValueA = qRound64(valueA);
// roundedValueA = 42949672960
qint64 roundedValueB = qRound64(valueB);
// roundedValueB = 42949672961

[constexpr] int qRound(double d)

将 d 四舍五入到最接近的整数。

四舍六入五取偶（例如，0.5 -> 1，-0.5 -> -1)。

示例

double valueA = 2.3;
double valueB = 2.7;

int roundedValueA = qRound(valueA);
// roundedValueA = 2
int roundedValueB = qRound(valueB);
// roundedValueB = 3

[constexpr] int qRound(float d)

将 d 四舍五入到最接近的整数。

将数值四舍五入到最近的整数（例如 0.5f 变为 1，-0.5f 变为 -1）。

示例

float valueA = 2.3;
float valueB = 2.7;

int roundedValueA = qRound(valueA);
// roundedValueA = 2
int roundedValueB = qRound(valueB);
// roundedValueB = 3

double qSNaN()

返回一个信号NaN的位模式作为双精度数。

[since 6.1] 模板 <typename T> typename std::enable_if_t<std::is_unsigned_v<T> || std::is_signed_v<T>, bool> qSubOverflow(T v1, T v2, T *result)

从 v1 中减去 v2，并将结果记录在 result 中。如果减法操作超出了类型 T 的有效范围，则返回 true，否则返回 false。

保证实现可供 8 位、16 位和 32 位整数类型以及指针尺寸的整数类型使用。对于其他类型的溢出数学（如果有的话），被认为是私有 API。

此函数在 Qt 6.1 中引入。