<QtNumeric> - Qt Numeric Functions

函数文档

[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

[constexpr, since 6.1] template <typename T> typename std::enable_if_t<std::is_unsigned_v<T>, bool> qAddOverflow(T v1, T v2, T *result)

将两个数值v1 和v2 （均为数值类型T ）相加，并将结果存储在result 中。如果加法运算导致数值超出类型T 的有效范围，则返回true ；否则返回false 。

保证提供适用于 8、16 和 32 位整数类型以及与指针大小相同的整数类型的实现。其他类型的溢出运算（如果可用）被视为私有 API。

该函数于 Qt 6.1 中引入。

quint64 qFloatDistance(double a, double b)

返回a 与b 之间可表示的浮点数个数。

该函数与qFloatDistance(float, float) 功能相同，但返回两个double 数值之间的距离。由于其范围比两个float 数值（[-DBL_MAX,DBL_MAX] ）的范围更大，因此返回类型为 quint64。

另请参阅 qFuzzyCompare()。

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()。

对浮点数值进行分类。

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

• FP_NAN 非数值
• FP_INFINITE 无穷大（正或负）
• FP_ZERO 零（正或负）
• FP_NORMAL 具有完整尾数的有限数
• FP_SUBNORMAL：具有缩减尾数的有界数

[constexpr noexcept] bool qFuzzyCompare(double p1, double p2)

比较浮点数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 noexcept] bool qFuzzyCompare(float p1, float p2)

比较浮点数p1 和p2 ，如果它们被视为相等，则返回true ；否则返回false 。

这两个数以相对方式进行比较，数值越小，比较的精确度越高。

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

[constexpr noexcept] bool qFuzzyIsNull(double d)

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

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

[constexpr noexcept] bool qFuzzyIsNull(float f)

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

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

double qInf()

返回一个无限数的二进制模式，类型为 double。

另请参阅 qIsInf()。

bool qIsFinite(double d)

如果双精度数d 是一个有限数，则返回true 。

bool qIsFinite(float f)

如果浮点数 `f ` 是有限数，则返回 `true `。

bool qIsInf(double d)

如果双精度数值 `d ` 等于无穷大，则返回 `true `。

另请参阅 qInf()。

bool qIsInf(float f)

如果浮点数 `f ` 等于无穷大，则返回 `true `。

另请参阅 qInf()。

bool qIsNaN(double d)

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

bool qIsNaN(float f)

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

[constexpr, since 6.1] template <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.3f;
float valueB = 42949672960.7f;

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.3f;
float valueB = 2.7f;

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

double qSNaN()

返回一个信号型 NaN 的位模式，类型为 double。

[constexpr, since 6.1] template <typename T> typename std::enable_if_t<std::is_unsigned_v<T>, bool> qSubOverflow(T v1, T v2, T *result)

从 `v1 ` 中减去 `v2 `，并将结果值存储在 `result` 中。如果减法运算导致 `T` 类型的有效范围溢出，则返回 `true`；否则返回 `false`。

保证提供针对 8 位、16 位和 32 位整数类型以及与指针大小相同的整数类型的实现。对于其他类型的溢出运算，如果可用，则被视为私有 API。

该函数于 Qt 6.1 中引入。