35 C 语言字符串转数值函数详解：strtof、strtod、strtold（含 errno 处理、ERANGE 错误）

news2025/6/8 10:38:42

1 strtof() 函数

1.1 函数原型

#include <stdlib.h> // 必须包含这个头文件才能使用 strtof()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 FlOAT_MAX 和 FLOAT_MIN
#include <math.h>   // 包含 HUGE_VALF(inf)

float strtof(const char *nptr, char **endptr);

1.2 功能说明

        strtof() 函数用于将字符串转换为单精度浮点数（float）。与 atof() 等函数相比，strtof() 提供了更灵活、安全的转换机制，支持完善的错误检查和转换结束位置定位。

  • 参数：
    • nptr：指向待转换的字符串（以空字符 \0 结尾）。
    • endptr：用于存储转换结束位置的指针。如果不需要使用该信息，可以将其设置为 NULL。
  • 返回值：
    • 成功转换：返回对应的 float 值。
    • 无效输入：若未执行任何转换，返回 0.0f。
    • 溢出情况：若转换结果超出 float 的表示范围：
      • 正溢出：返回 HUGE_VALF（表示正无穷大，inf），并设置 errno 为 ERANGE。
      • 负溢出：返回 -HUGE_VALF（表示负无穷大，-inf），并设置 errno 为 ERANGE。
    • 下溢情况：若转换结果绝对值过小（小于 FLT_MIN），返回 0.0f，并设置 errno 为 ERANGE（但某些实现可能不会设置 errno，具体行为取决于实现）。

错误处理与范围检查相关概念：

  1. errno
    • 含义：errno 是一个全局变量（类型为 int，定义在 <errno.h> 头文件中），用于存储最近一次函数调用产生的错误代码。
    • 作用：当 strtof() 等函数检测到错误（如数值溢出或下溢）时，会将 errno 设置为特定的错误码（如 ERANGE），以指示错误类型。
    • 使用建议：在调用 strtof() 之前，应清除 errno（例如，通过 errno = 0），以便在转换后能够正确检测到是否发生了错误。
  2. ERANGE
    • 含义：RANGE 是一个宏常量（通常值为 34，定义在 <errno.h> 头文件中），表示 “结果超出范围”（Range Error）。
    • 使用场景：当 strtof() 检测到输入的字符串表示的数值超出 float 的表示范围（过大或过小）时，会将 errno 设置为 ERANGE，表明发生了溢出或下溢错误。
  3. HUGE_VALF
    • 含义：HUGE_VALF 是一个宏常量（定义在 <math.h> 头文件中），表示正无穷大（inf）的 float 值。
    • 使用场景：当 strtof() 发生正溢出时，返回 HUGE_VALF（inf）。
  4. FLT_MAX 和 FLT_MIN
    • 含义：FLT_MAX 和 FLT_MIN 是宏定义（定义在 <float.h> 头文件中），分别表示 float 类型的最大值和最小正规范化值。
    • 使用场景：
      • 若输入字符串表示的数值超过 FLT_MAX，strtof() 会返回 HUGE_VALF（inf）并设置 errno 为 ERANGE。
      • 若输入字符串表示的数值绝对值小于 FLT_MIN，strtof() 会返回 0.0f 并可能设置 errno 为 ERANGE（取决于实现）。

1.3 转换规则

  1. 忽略前导空格：在解析字符串时，自动跳过字符串开头处的所有空白字符，包括空格（' '）、制表符（'\t'）、换行符（'\n'）等。
  2. 识别正负号：支持在数字前添加可选的符号字符：
    1. '+' 表示最终数值为正数。
    2. '-' 表示最终数值为负数。
    3. 若未指定符号，默认数值为正数。
  3. 读取数字：解析字符串中的数字部分，支持以下格式：
    1. 整数部分（如 "123"）。
    2. 小数部分（如 ".123" 或 "123.456"）。
    3. 指数部分（如 "1.23e4" 或 "1.23E-4"）。
  4. 停止转换：遇到第一个不符合浮点数规则的字符时停止解析，后续字符将被忽略。
  5. 返回结果：将解析的数字转换为 float 类型返回。
  6. 错误处理：
    1. 完全成功转换：
      1. endptr 指向字符串末尾的空字符 '\0'，可通过 if (*endptr == '\0') 验证。
      2. 示例："3.1415926", NULL → 返回 3.141593。
    2. 部分成功转换：
      1. endptr 指向第一个非数字字符，可通过 if (*endptr != '\0') 验证。
      2. 示例："3.14abc", NULL → 返回 3.14，endptr 指向 'a'。
    3. 无效输入：
      1. endptr 指向原始字符串起始地址，可通过 if (endptr == str) 验证（str 为原始字符串指针）。
      2. 示例："HelloWorld", NULL → 返回 0.0f，endptr 指向 'H'。
    4. 溢出处理：需结合 errno 和 endptr 进行判断。
      1. 正溢出：
        1. 返回 HUGE_VALF（表示正无穷大，inf），并设置 errno 为 ERANGE。
        2. 示例："1e50", NULL → 返回 HUGE_VALF。
      2. 负溢出：
        1. 返回 -HUGE_VALF（表示负无穷大，-inf），并设置 errno 为 ERANGE。
        2. 示例："-1e50", NULL → 返回 -HUGE_VALF。
      3. 下溢：
        1. 返回 0.0f，并可能设置 errno 为 ERANGE（具体行为取决于实现）。
        2. 示例："1e-50", NULL → 返回 0.0f。

        转换示例：

输入字符串endptr 参数返回值说明
"3.1415926"NULL3.141593f完全成功转换
"-2.71828"NULL-2.718280f完全成功转换（负数）
"    +123.456"NULL123.456000f忽略前导空格
"3.14abc"NULL3.140000f部分成功转换，endptr 指向 'a'
"HelloWorld"NULL0.000000f无效输入，endptr 指向 'H'
"1.23e4"NULL12300.000000f科学计数法转换
"1e50"NULLHUGE_VALF（inf）正溢出
"-1e50"NULL-HUGE_VALF（-inf）负溢出
"1e-50"NULL0.000000f下溢

1.4 注意事项

  1. 错误检测：
    1. 方法：通过检查 endptr 是否等于原始字符串的起始地址（str）来判断转换是否完全失败。
    2. 细节：
      1. 若 endptr == str：表示未解析出任何有效数字（如输入为 "HelloWorld"）。
      2. 若 *endptr != '\0'：表示部分成功转换如输入为 "123.45abc"，endptr 指向 'a'）。
      3. 若 *endptr == '\0'：表示完全成功转换（如输入为 "123.45"）。
  2. 溢出处理：
    1. 条件：当输入的数值超出 float 的表示范围时，strtof() 会设置 errno 为 ERANGE。
    2. 行为：
      1. 正溢出：返回 HUGE_VALF（inf）。
      2. 负溢出：返回 -HUGE_VALF（-inf）。
    3. 建议：在调用 strtof() 前，应清除 errno（如 errno = 0），以便后续检测。
  3. 科学计数法支持：strtof() 支持科学计数法（如 "1.23e4" 或 "1.23E-4"），这是 atof() 等函数不具备的特性。
  4. 推荐使用：相比 atof()，strtof() 更安全，支持错误检查和更灵活的浮点数格式解析。

1.5 示例程序

#include <stdio.h>
#include <stdlib.h> // 必须包含这个头文件才能使用 strtof()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 FlOAT_MAX 和 FLOAT_MIN
#include <math.h>   // 包含 HUGE_VALF

int main()
{
    char *endptr; // 用于存储转换结束的位置
    float result; // 用于存储转换结果

    // 示例 1：基本转换
    result = strtof("3.1415926", &endptr);
    printf("转换结果1: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果1: 3.141593, 结束位置: (null)

    // 示例 2：带符号的数字
    result = strtof("-2.71828", &endptr);
    printf("转换结果2: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果2: -2.718280, 结束位置: (null)

    // 示例 3：带前导空格和符号
    result = strtof("    +123.456", &endptr);
    printf("转换结果3: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果3: 123.456000, 结束位置: (null)

    // 示例 4：部分有效的数字
    result = strtof("3.14abc", &endptr);
    printf("转换结果4: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果4: 3.140000, 结束位置: abc

    // 示例 5：无效输入
    result = strtof("HelloWorld", &endptr);
    printf("转换结果5: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果5: 0.000000, 结束位置: HelloWorld

    // 示例 6：科学计数法
    result = strtof("1.23e4", &endptr);
    printf("转换结果6: %f, 结束位置: %s\n", result, endptr); // 输出: 转换结果6: 12300.000000, 结束位置: (null)

    // 示例 7：正溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtof("1e50", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);             // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VALF: %f\n", HUGE_VALF);                           // 输出: HUGE_VALF: inf
        printf("  FLOAT_MAX: %e, FLOAT_MIN: %e\n", FLT_MAX, FLT_MIN);     // 输出: FLOAT_MAX: 3.402823e+38, FLOAT_MIN: 1.175494e-38
        printf("转换结果7: 超出范围，返回 HUGE_VALF(inf): %f\n", result); // 输出: 转换结果7: 超出范围，返回 HUGE_VALF(inf): inf
    }
    else
    {
        printf("转换结果7: %f\n", result);
    }

    // 示例 8：负溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtof("-1e50", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);               // 输出: errno = 34, ERANGE = 34
        printf("  -HUGE_VALF: %f\n", -HUGE_VALF);                           // 输出: -HUGE_VALF: -inf
        printf("  FLOAT_MAX: %e, FLOAT_MIN: %e\n", FLT_MAX, FLT_MIN);       // 输出: FLOAT_MAX: 3.402823e+38, FLOAT_MIN: 1.175494e-38
        printf("转换结果8: 超出范围，返回 -HUGE_VALF(-inf): %f\n", result); // 输出: 转换结果8: 超出范围，返回 -HUGE_VALF(-inf): -inf
    }
    else
    {
        printf("转换结果8: %f\n", result);
    }

    // 示例 9：下溢检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtof("1e-50", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);                             // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VALF: %f, -HUGE_VALF: %f\n", HUGE_VALF, -HUGE_VALF);               // 输出: HUGE_VALF: inf, -HUGE_VALF: -inf
        printf("  FLOAT_MAX: %e, FLOAT_MIN: %e\n", FLT_MAX, FLT_MIN);                     // 输出: FLOAT_MAX: 3.402823e+38, FLOAT_MIN: 1.175494e-38
        printf("转换结果9: 字符串表示的数值绝对值小于 FLT_MIN，返回 0.0f: %f\n", result); // 输出: 转换结果9: 字符串表示的数值绝对值小于 FLT_MIN，返回 0.0f: 0.000000
    }
    else
    {
        printf("转换结果9: %f\n", result);
    }

    // 示例 10：检查转换是否完全成功
    result = strtof("123.456abc", &endptr);
    if (*endptr != '\0')
    {
        printf("转换结果10: %f, 但字符串未完全转换\n", result); // 输出: 转换结果10: 123.456000, 但字符串未完全转换
    }
    else
    {
        printf("转换结果10: %f\n", result);
    }

    return 0;
}

        程序在 VS Code 中的运行结果如下所示：

2 strtod() 函数

2.1 函数原型

#include <stdlib.h> // 必须包含这个头文件才能使用 strtod()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 DBL_MAX 和 DBL_MIN
#include <math.h>   // 包含 HUGE_VAL

double strtod(const char *nptr, char **endptr);

2.2 功能说明

        strtod() 函数用于将字符串转换为双精度浮点数（double）。与 atof() 等函数相比，strtod() 提供了更灵活、安全的转换机制，支持完善的错误检查和转换结束位置定位。

  • 参数：
    • nptr：指向待转换的字符串（以空字符 \0 结尾）。
    • endptr：用于存储转换结束位置的指针。如果不需要使用该信息，可以将其设置为 NULL。
  • 返回值：
    • 成功转换：返回对应的 double 值。
    • 无效输入：若未执行任何转换，返回 0.0。
    • 溢出情况：若转换结果超出 double 的表示范围：
      • 正溢出：返回 HUGE_VAL（表示正无穷大，inf），并设置 errno 为 ERANGE。
      • 负溢出：返回 -HUGE_VAL（表示负无穷大，-inf），并设置 errno 为 ERANGE。
    • 下溢情况：若转换结果绝对值过小（小于 DBL_MIN），返回 0.0，并设置 errno 为 ERANGE（但某些实现可能不会设置 errno，具体行为取决于实现）。

错误处理与范围检查相关概念：

  1. errno
    • 含义：errno 是一个全局变量（类型为 int，定义在 <errno.h> 头文件中），用于存储最近一次函数调用产生的错误代码。
    • 作用：当 strtod() 等函数检测到错误（如数值溢出或下溢）时，会将 errno 设置为特定的错误码（如 ERANGE），以指示错误类型。
    • 使用建议：在调用 strtod() 之前，应清除 errno（例如，通过 errno = 0），以便在转换后能够正确检测到是否发生了错误。
  2. ERANGE
    • 含义：RANGE 是一个宏常量（通常值为 34，定义在 <errno.h> 头文件中），表示 “结果超出范围”（Range Error）。
    • 使用场景：当 strtod() 检测到输入的字符串表示的数值超出 double 的表示范围（过大或过小）时，会将 errno 设置为 ERANGE，表明发生了溢出或下溢错误。
  3. HUGE_VAL
    • 含义：HUGE_VAL 是一个宏常量（定义在 <math.h> 头文件中），表示正无穷大（inf）的 double 值。
    • 使用场景：当 strtod() 发生正溢出时，返回 HUGE_VAL（inf）。
  4. DBL_MAX 和 DBL_MIN
    • 含义：DBL_MAX 和 DBL_MIN 是宏定义（定义在 <float.h> 头文件中），分别表示 double 类型的最大值和最小正规范化值。
    • 使用场景：
      • 若输入字符串表示的数值超过 DBL_MAX，strtod() 会返回 HUGE_VAL（inf）并设置 errno 为 ERANGE。
      • 若输入字符串表示的数值绝对值小于 DBL_MIN，strtod() 会返回 0.0 并可能设置 errno 为 ERANGE（取决于实现）。

2.3 转换规则

  1. 忽略前导空格：在解析字符串时，自动跳过字符串开头处的所有空白字符，包括空格（' '）、制表符（'\t'）、换行符（'\n'）等。
  2. 识别正负号：支持在数字前添加可选的符号字符：
    1. '+' 表示最终数值为正数。
    2. '-' 表示最终数值为负数。
    3. 若未指定符号，默认数值为正数。
  3. 读取数字：解析字符串中的数字部分，支持以下格式：
    1. 整数部分（如 "123"）。
    2. 小数部分（如 ".123" 或 "123.456"）。
    3. 指数部分（如 "1.23e4" 或 "1.23E-4"）。
  4. 停止转换：遇到第一个不符合浮点数规则的字符时停止解析，后续字符将被忽略。
  5. 返回结果：将解析的数字转换为 double 类型返回。
  6. 错误处理：
    1. 完全成功转换：
      1. endptr 指向字符串末尾的空字符 '\0'，可通过 if (*endptr == '\0') 验证。
      2. 示例："3.1415926", NULL → 返回 3.141593。
    2. 部分成功转换：
      1. endptr 指向第一个非数字字符，可通过 if (*endptr != '\0') 验证。
      2. 示例："3.14abc", NULL → 返回 3.14，endptr 指向 'a'。
    3. 无效输入：
      1. endptr 指向原始字符串起始地址，可通过 if (endptr == str) 验证（str 为原始字符串指针）。
      2. 示例："HelloWorld", NULL → 返回 0.0f，endptr 指向 'H'。
    4. 溢出处理：需结合 errno 和 endptr 进行判断。
      1. 正溢出：
        1. 返回 HUGE_VAL（表示正无穷大，inf），并设置 errno 为 ERANGE。
        2. 示例："1e500", NULL → 返回 HUGE_VAL。
      2. 负溢出：
        1. 返回 -HUGE_VAL（表示负无穷大，-inf），并设置 errno 为 ERANGE。
        2. 示例："-1e500", NULL → 返回 -HUGE_VAL。
      3. 下溢：
        1. 返回 0.0，并可能设置 errno 为 ERANGE（具体行为取决于实现）。
        2. 示例："1e-500", NULL → 返回 0.0。

        转换示例：

输入字符串endptr 参数返回值说明
"3.1415926"NULL3.141593完全成功转换
"-2.71828"NULL-2.718280完全成功转换（负数）
"    +123.456"NULL123.456000忽略前导空格
"3.14abc"NULL3.140000部分成功转换，endptr 指向 'a'
"HelloWorld"NULL0.000000无效输入，endptr 指向 'H'
"1.23e4"NULL12300.000000科学计数法转换
"1e500"NULLHUGE_VAL（inf）正溢出
"-1e500"NULL-HUGE_VAL（-inf）负溢出
"1e-500"NULL0.000000下溢

2.4 注意事项

  1. 错误检测：
    1. 方法：通过检查 endptr 是否等于原始字符串的起始地址（str）来判断转换是否完全失败。
    2. 细节：
      1. 若 endptr == str：表示未解析出任何有效数字（如输入为 "HelloWorld"）。
      2. 若 *endptr != '\0'：表示部分成功转换如输入为 "123.45abc"，endptr 指向 'a'）。
      3. 若 *endptr == '\0'：表示完全成功转换（如输入为 "123.45"）。
  2. 溢出处理：
    1. 条件：当输入的数值超出 double 的表示范围时，strtod() 会设置 errno 为 ERANGE。
    2. 行为：
      1. 正溢出：返回 HUGE_VAL（inf）。
      2. 负溢出：返回 -HUGE_VAL（-inf）。
    3. 建议：在调用 strtod() 前，应清除 errno（如 errno = 0），以便后续检测。
  3. 科学计数法支持：strtod() 支持科学计数法（如 "1.23e4" 或 "1.23E-4"），这是 atof() 等函数不具备的特性。
  4. 推荐使用：相比 atof()，strtod() 更安全，支持错误检查和更灵活的浮点数格式解析。

2.5 示例程序

#include <stdio.h>
#include <stdlib.h> // 必须包含这个头文件才能使用 strtod()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 DBL_MAX 和 DBL_MIN
#include <math.h>   // 包含 HUGE_VAL

int main()
{
    char *endptr;  // 用于存储转换结束的位置
    double result; // 用于存储转换结果（改为 double 类型）

    // 示例 1：基本转换
    result = strtod("3.1415926", &endptr);
    printf("转换结果1: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果1: 3.141593, 结束位置: (null)

    // 示例 2：带符号的数字
    result = strtod("-2.71828", &endptr);
    printf("转换结果2: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果2: -2.718280, 结束位置: (null)

    // 示例 3：带前导空格和符号
    result = strtod("    +123.456", &endptr);
    printf("转换结果3: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果3: 123.456001, 结束位置: (null)

    // 示例 4：部分有效的数字
    result = strtod("3.14abc", &endptr);
    printf("转换结果4: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果4: 3.140000, 结束位置: abc

    // 示例 5：无效输入
    result = strtod("HelloWorld", &endptr);
    printf("转换结果5: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果5: 0.000000, 结束位置: HelloWorld

    // 示例 6：科学计数法
    result = strtod("1.23e4", &endptr);
    printf("转换结果6: %lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果6: 12300.000000, 结束位置: (null)

    // 示例 7：正溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtod("1e500", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);             // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VAL: %lf\n", HUGE_VAL);                            // 输出: HUGE_VAL: inf
        printf("  DBL_MAX: %e, DBL_MIN: %e\n", DBL_MAX, DBL_MIN);         // 输出: DBL_MAX: 1.797693e+308, DBL_MIN: 2.225074e-308
        printf("转换结果7: 超出范围，返回 HUGE_VAL(inf): %lf\n", result); // 输出: 转换结果7: 超出范围，返回 HUGE_VAL(inf): inf
    }
    else
    {
        printf("转换结果7: %lf\n", result);
    }

    // 示例 8：负溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtod("-1e500", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);               // 输出: errno = 34, ERANGE = 34
        printf("  -HUGE_VAL: %lf\n", -HUGE_VAL);                            // 输出: -HUGE_VAL: -inf
        printf("  DBL_MAX: %e, DBL_MIN: %e\n", DBL_MAX, DBL_MIN);           // 输出: DBL_MAX: 1.797693e+308, DBL_MIN: 2.225074e-308
        printf("转换结果8: 超出范围，返回 -HUGE_VAL(-inf): %lf\n", result); // 输出: 转换结果8: 超出范围，返回 -HUGE_VAL(-inf): -inf
    }
    else
    {
        printf("转换结果8: %lf\n", result);
    }

    // 示例 9：下溢检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtod("1e-500", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);                            // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VALF: %f, -HUGE_VALF: %f\n", HUGE_VALF, -HUGE_VALF);              // 输出: HUGE_VALF: inf, -HUGE_VALF: -inf
        printf("  DBL_MAX: %e, DBL_MIN: %e\n", DBL_MAX, DBL_MIN);                        // 输出: DBL_MAX: 1.797693e+308, DBL_MIN: 2.225074e-308
        printf("转换结果9: 字符串表示的数值绝对值小于 DBL_MIN，返回 0.0: %f\n", result); // 输出: 转换结果9: 字符串表示的数值绝对值小于 DBL_MIN，返回 0.0: 0.000000
    }
    else
    {
        printf("转换结果9: %lf\n", result);
    }

    // 示例 10：检查转换是否完全成功
    result = strtod("123.45abc", &endptr);
    if (*endptr != '\0')
    {
        printf("转换结果10: %lf, 但字符串未完全转换\n", result); // 输出: 转换结果10: 123.450000, 但字符串未完全转换
    }
    else
    {
        printf("转换结果10: %lf\n", result);
    }

    return 0;
}

        程序在 VS Code 中的运行结果如下所示：

3 strtold() 函数

3.1 函数原型

#include <stdlib.h> // 必须包含这个头文件才能使用 strtold()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 LDBL_MAX 和 LDBL_MIN
#include <math.h>   // 包含 HUGE_VALL

long double strtold(const char *nptr, char **endptr);

3.2 功能说明

        strtold() 函数用于将字符串转换为长双精度浮点数（long double）。与 atof() 等函数相比，strtold() 提供了更灵活、安全的转换机制，支持完善的错误检查和转换结束位置定位。

  • 参数：
    • nptr：指向待转换的字符串（以空字符 \0 结尾）。
    • endptr：用于存储转换结束位置的指针。如果不需要使用该信息，可以将其设置为 NULL。
  • 返回值：
    • 成功转换：返回对应的 long double 值。
    • 无效输入：若未执行任何转换，返回 0.0L。
    • 溢出情况：若转换结果超出 long double 的表示范围：
      • 正溢出：返回 HUGE_VALL（表示正无穷大，inf），并设置 errno 为 ERANGE。
      • 负溢出：返回 -HUGE_VALL（表示负无穷大，-inf），并设置 errno 为 ERANGE。
    • 下溢情况：若转换结果绝对值过小（小于 LDBL_MIN），返回 0.0L，并设置 errno 为 ERANGE（但某些实现可能不会设置 errno，具体行为取决于实现）。

错误处理与范围检查相关概念：

  1. errno
    • 含义：errno 是一个全局变量（类型为 int，定义在 <errno.h> 头文件中），用于存储最近一次函数调用产生的错误代码。
    • 作用：当 strtold() 等函数检测到错误（如数值溢出或下溢）时，会将 errno 设置为特定的错误码（如 ERANGE），以指示错误类型。
    • 使用建议：在调用 strtold() 之前，应清除 errno（例如，通过 errno = 0），以便在转换后能够正确检测到是否发生了错误。
  2. ERANGE
    • 含义：RANGE 是一个宏常量（通常值为 34，定义在 <errno.h> 头文件中），表示 “结果超出范围”（Range Error）。
    • 使用场景：当 strtold() 检测到输入的字符串表示的数值超出 long double 的表示范围（过大或过小）时，会将 errno 设置为 ERANGE，表明发生了溢出或下溢错误。
  3. HUGE_VALL
    • 含义：HUGE_VALL 是一个宏常量（定义在 <math.h> 头文件中），表示正无穷大（inf）的 long double 值。
    • 使用场景：当 strtold() 发生正溢出时，返回 HUGE_VALL（inf）。
  4. LDBL_MAX 和 LDBL_MIN
    • 含义：LDBL_MAX 和 LDBL_MIN 是宏定义（定义在 <float.h> 头文件中），分别表示 long double 类型的最大值和最小正规范化值。
    • 使用场景：
      • 若输入字符串表示的数值超过 LDBL_MAX，strtold() 会返回 HUGE_VALL（inf）并设置 errno 为 ERANGE。
      • 若输入字符串表示的数值绝对值小于 LDBL_MIN，strtold() 会返回 0.0L 并可能设置 errno 为 ERANGE（取决于实现）。

3.3 转换规则

  1. 忽略前导空格：在解析字符串时，自动跳过字符串开头处的所有空白字符，包括空格（' '）、制表符（'\t'）、换行符（'\n'）等。
  2. 识别正负号：支持在数字前添加可选的符号字符：
    1. '+' 表示最终数值为正数。
    2. '-' 表示最终数值为负数。
    3. 若未指定符号，默认数值为正数。
  3. 读取数字：解析字符串中的数字部分，支持以下格式：
    1. 整数部分（如 "123"）。
    2. 小数部分（如 ".123" 或 "123.456"）。
    3. 指数部分（如 "1.23e4" 或 "1.23E-4"）。
  4. 停止转换：遇到第一个不符合浮点数规则的字符时停止解析，后续字符将被忽略。
  5. 返回结果：将解析的数字转换为 long double 类型返回。
  6. 错误处理：
    1. 完全成功转换：
      1. endptr 指向字符串末尾的空字符 '\0'，可通过 if (*endptr == '\0') 验证。
      2. 示例："3.1415926535", NULL → 返回 3.141593。
    2. 部分成功转换：
      1. endptr 指向第一个非数字字符，可通过 if (*endptr != '\0') 验证。
      2. 示例："3.14abc", NULL → 返回 3.14，endptr 指向 'a'。
    3. 无效输入：
      1. endptr 指向原始字符串起始地址，可通过 if (endptr == str) 验证（str 为原始字符串指针）。
      2. 示例："HelloWorld", NULL → 返回 0.0f，endptr 指向 'H'。
    4. 溢出处理：需结合 errno 和 endptr 进行判断。
      1. 正溢出：
        1. 返回 HUGE_VALL（表示正无穷大，inf），并设置 errno 为 ERANGE。
        2. 示例："1e5000", NULL → 返回 HUGE_VALL。
      2. 负溢出：
        1. 返回 -HUGE_VALL（表示负无穷大，-inf），并设置 errno 为 ERANGE。
        2. 示例："-1e5000", NULL → 返回 -HUGE_VALL。
      3. 下溢：
        1. 返回 0.0f，并可能设置 errno 为 ERANGE（具体行为取决于实现）。
        2. 示例："1e-5000", NULL → 返回 0.0L。

        转换示例：

输入字符串endptr 参数返回值说明
"3.1415926535"NULL3.141593L完全成功转换
"-2.718281828"NULL-2.718282L完全成功转换（负数）
"    +123.456"NULL123.456000L忽略前导空格
"3.14abc"NULL3.140000L部分成功转换，endptr 指向 'a'
"HelloWorld"NULL0.000000L无效输入，endptr 指向 'H'
"1.23e4"NULL12300.000000L科学计数法转换
"1e5000"NULLHUGE_VALL（inf）正溢出
"-1e5000"NULL-HUGE_VALL（-inf）负溢出
"1e-5000"NULL0.000000L下溢

3.4 注意事项

  1. 错误检测：
    1. 方法：通过检查 endptr 是否等于原始字符串的起始地址（str）来判断转换是否完全失败。
    2. 细节：
      1. 若 endptr == str：表示未解析出任何有效数字（如输入为 "HelloWorld"）。
      2. 若 *endptr != '\0'：表示部分成功转换如输入为 "123.45abc"，endptr 指向 'a'）。
      3. 若 *endptr == '\0'：表示完全成功转换（如输入为 "123.45"）。
  2. 溢出处理：
    1. 条件：当输入的数值超出 long double 的表示范围时，strtold() 会设置 errno 为 ERANGE。
    2. 行为：
      1. 正溢出：返回 HUGE_VALL（inf）。
      2. 负溢出：返回 -HUGE_VALL（-inf）。
    3. 建议：在调用 strtold() 前，应清除 errno（如 errno = 0），以便后续检测。
  3. 科学计数法支持：strtold() 支持科学计数法（如 "1.23e4" 或 "1.23E-4"），这是 atof() 等函数不具备的特性。
  4. 推荐使用：相比 atof()，strtold() 更安全，支持错误检查和更灵活的浮点数格式解析。

3.5 示例程序

#include <stdio.h>
#include <stdlib.h> // 必须包含这个头文件才能使用 strtold()
#include <errno.h>  // 包含 errno 和 ERANGE
#include <float.h>  // 包含 LDBL_MAX 和 LDBL_MIN
#include <math.h>   // 包含 HUGE_VALL

int main()
{
    char *endptr;       // 用于存储转换结束的位置
    long double result; // 用于存储转换结果（改为 long double 类型）

    // 示例 1：基本转换
    result = strtold("3.1415926535", &endptr);
    printf("转换结果1: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果1: 3.141593, 结束位置: (null)

    // 示例 2：带符号的数字
    result = strtold("-2.718281828", &endptr);
    printf("转换结果2: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果2: -2.718282, 结束位置: (null)

    // 示例 3：带前导空格和符号
    result = strtold("    +123.456", &endptr);
    printf("转换结果3: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果3: 123.456000, 结束位置: (null)

    // 示例 4：部分有效的数字
    result = strtold("3.14abc", &endptr);
    printf("转换结果4: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果4: 3.140000, 结束位置: abc

    // 示例 5：无效输入
    result = strtold("HelloWorld", &endptr);
    printf("转换结果5: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果5: 0.000000, 结束位置: HelloWorld

    // 示例 6：科学计数法
    result = strtold("1.23e4", &endptr);
    printf("转换结果6: %Lf, 结束位置: %s\n", result, endptr); // 输出: 转换结果6: 12300.000000, 结束位置: (null)

    // 示例 7：正溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtold("1e5000", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);              // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VALL: %Lf\n", HUGE_VALL);                           // 输出: HUGE_VALL: inf
        printf("  LDBL_MAX: %Le, LDBL_MIN: %Le\n", LDBL_MAX, LDBL_MIN);    // 输出: LDBL_MAX: 1.189731e+4932, LDBL_MIN: 3.362103e-4932
        printf("转换结果7: 超出范围，返回 HUGE_VALL(inf): %Lf\n", result); // 输出: 转换结果7: 超出范围，返回 HUGE_VALL(inf): inf
    }
    else
    {
        printf("转换结果7: %Lf\n", result);
    }

    // 示例 8：负溢出检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtold("-1e5000", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);                // 输出: errno = 34, ERANGE = 34
        printf("  -HUGE_VALL: %Lf\n", -HUGE_VALL);                           // 输出: -HUGE_VALL: -inf
        printf("  LDBL_MAX: %Le, LDBL_MIN: %Le\n", LDBL_MAX, LDBL_MIN);      // 输出: LDBL_MAX: 1.189731e+4932, LDBL_MIN: 3.362103e-4932
        printf("转换结果8: 超出范围，返回 -HUGE_VALL(-inf): %Lf\n", result); // 输出: 转换结果8: 超出范围，返回 -HUGE_VALL(-inf): -inf
    }
    else
    {
        printf("转换结果8: %Lf\n", result);
    }

    // 示例 9：下溢检测
    errno = 0; // 重置 errno, 清除之前的错误
    result = strtold("1e-5000", &endptr);
    if (errno == ERANGE)
    {
        printf("  errno = %d, ERANGE = %d\n", errno, ERANGE);                               // 输出: errno = 34, ERANGE = 34
        printf("  HUGE_VALF: %f, -HUGE_VALF: %f\n", HUGE_VALF, -HUGE_VALF);                 // 输出: HUGE_VALF: inf, -HUGE_VALF: -inf
        printf("  LDBL_MAX: %Le, LDBL_MIN: %Le\n", LDBL_MAX, LDBL_MIN);                     // 输出: LDBL_MAX: 1.189731e+4932, LDBL_MIN: 3.362103e-4932
        printf("转换结果9: 字符串表示的数值绝对值小于 LDBL_MIN，返回 0.0L: %Lf\n", result); // 输出: 转换结果9: 字符串表示的数值绝对值小于 LDBL_MIN，返回 0.0L: 0.000000
    }
    else
    {
        printf("转换结果9: %Lf\n", result);
    }

    // 示例 10：检查转换是否完全成功
    result = strtold("123.45abc", &endptr);
    if (*endptr != '\0')
    {
        printf("转换结果10: %Lf, 但字符串未完全转换\n", result); // 输出: 转换结果10: 123.450000, 但字符串未完全转换
    }
    else
    {
        printf("转换结果9: %Lf\n", result);
    }

    return 0;
}

        程序在 VS Code 中的运行结果如下所示：

4 字符串转数值函数总结

函数名功能返回值类型转换范围适用场景错误处理（errno）
strtof将字符串转换为单精度浮点型（float）floatFLT_MIN 到 FLT_MAX（通常为 1.175494e-38 到 3.402823e+38）需要处理单精度浮点数的转换

无效输入时返回 0.0f；

正溢出时返回 +HUGE_VALF（inf）；

负溢出时返回 -HUGE_VALF（-inf）；

下溢时可能返回 0.0f 或次正规数（取决于实现），并设置 errno 为 ERANGE（仅溢出时设置）

strtod将字符串转换为双精度浮点型（double）doubleDBL_MIN 到 DBL_MAX（通常为 2.225074e-308 到 1.797693e+308）需要处理双精度浮点数的转换

无效输入时返回 0.0；

正溢出时返回 +HUGE_VAL（inf）；

负溢出时返回 -HUGE_VAL（-inf）；

下溢时可能返回 0.0 或次正规数（取决于实现），并设置 errno 为 ERANGE（仅溢出时设置）

strtold将字符串转换为扩展精度浮点型（long double）long doubleLDBL_MIN 到 LDBL_MAX（范围因平台而异，通常更大）需要处理高精度或大范围浮点数的转换

无效输入时返回 0.0L；

正溢出时返回 +HUGE_VALL（inf）；

负溢出时返回 -HUGE_VALL（-inf）；

下溢时可能返回 0.0L 或次正规数（取决于实现），并设置 errno 为 ERANGE（仅溢出时设置）

  • 头文件：所有这些函数都定义在 <stdlib.h> 头文件中，使用时需要包含该头文件。

  • 错误处理细节：

    • 当转换结果超出目标类型的最大正值时，函数返回 +HUGE_VALF、+HUGE_VAL 或 +HUGE_VALL（取决于函数类型），并设置 errno 为 ERANGE。
    • 当转换结果小于目标类型的最小负值时，函数返回 -HUGE_VALF、-HUGE_VAL 或 -HUGE_VALL（取决于函数类型），并设置 errno 为 ERANGE。
    • 当转换结果非常接近零，但仍在目标类型的范围内时，函数可能返回 0.0、0.0f、0.0L 或一个次正规数（即一个非常小的非零值，其精度可能低于正常范围的数值）。下溢通常不会设置 errno 为 ERANGE，除非在某些特定实现中明确规定。

  • 跨平台兼容性：

    • 这些函数是 C 标准库的一部分，因此在大多数平台上都可用。
    • 浮点类型的范围（如 FLT_MAX、DBL_MAX、LDBL_MAX）和精度（如 FLT_DIG、DBL_DIG、LDBL_DIG）可能因平台和编译器实现而异，因此在跨平台开发时需要注意这些差异。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2404031.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

日志收集工具-Filebeat

日志收集工具-Filebeat

提示&#xff1a;windows 环境下 Filebeat 的安装与使用 文章目录 前言一、安装二、配置部署三、启动测试 前言 Filebeat 一般用于日志采集&#xff0c;由两部分组成 &#xff1a;Harvesters 和 prospector Harvesters采集器&#xff1a;逐行读取单个文件的内容&#xff0c;并…
阅读更多...
Vue3学习（4）- computed的使用

Vue3学习（4）- computed的使用

1. 简述与使用 作用&#xff1a;computed 用于基于响应式数据派生出新值&#xff0c;其值会自动缓存并在依赖变化时更新。 ​缓存机制​&#xff1a;依赖未变化时直接返回缓存值&#xff0c;避免重复计算&#xff08;通过 _dirty 标志位实现&#xff09;。​响应式更新​&…
阅读更多...
手机上网可以固定ip地址吗？详细解析

手机上网可以固定ip地址吗？详细解析

在移动互联网时代&#xff0c;手机已成为人们日常上网的主要设备之一。无论是工作、学习还是娱乐&#xff0c;稳定的网络连接都至关重要。许多用户对IP地址的概念有所了解&#xff0c;尤其是固定IP地址的需求。那么&#xff0c;手机上网能否固定IP地址&#xff1f;又该如何实现…
阅读更多...
如何在Unity中实现点击一个按钮跳转到哔哩哔哩

如何在Unity中实现点击一个按钮跳转到哔哩哔哩

1.创建一个按钮 2.编写一个脚本&#xff08;你可以把链接改成你想要跳转的网站&#xff09; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI;public class JumpToBilibili : MonoBehaviour {void Start(){gameObject.…
阅读更多...
PySide6 GUI 学习笔记——常用类及控件使用方法（单行文本控件QLineEdit）

PySide6 GUI 学习笔记——常用类及控件使用方法（单行文本控件QLineEdit）

文章目录 QLineEdit 介绍常用方法QLineEdit.EchoMode 取值光标相关方法文本选择方法输入格式化字符&#xff08;Input Mask&#xff09;常用信号QLineEdit 实例 QLineEdit 介绍 QLineEdit 是 PySide6&#xff08;Qt for Python&#xff09;中用于单行文本输入的控件。它支持文本…
阅读更多...
【数据结构】6. 时间与空间复杂度

【数据结构】6. 时间与空间复杂度

文章目录 一、算法效率1、算法的复杂度 二、时间复杂度1、时间复杂度的概念2、大O的渐进表示法3、常见时间复杂度计算1&#xff09;实例12&#xff09;实例23&#xff09;实例34&#xff09;实例45&#xff09;实例56&#xff09;实例67&#xff09;实例78&#xff09;实例8 三…
阅读更多...
基于springboot的藏文古籍系统

基于springboot的藏文古籍系统

博主介绍&#xff1a;高级开发&#xff0c;从事互联网行业六年&#xff0c;熟悉各种主流语言&#xff0c;精通java、python、php、爬虫、web开发&#xff0c;已经做了多年的设计程序开发&#xff0c;开发过上千套设计程序&#xff0c;没有什么华丽的语言&#xff0c;只有实实在…
阅读更多...
重构城市应急指挥布控策略 ——无人机智能视频监控的破局之道

重构城市应急指挥布控策略 ——无人机智能视频监控的破局之道

在突发事件、高空巡查、边远区域布控中&#xff0c;传统摄像头常常“看不到、跟不上、调不动”。无人机智能视频监控系统&#xff0c;打破地面视角局限&#xff0c;以“高空布控 AI分析 实时响应”赋能政企单位智能化管理。在城市应急指挥中心的大屏上&#xff0c;一场暴雨正…
阅读更多...
声音信号的基频检测(python版本)

声音信号的基频检测(python版本)

import math import wave import array import functools from abc import ABC, abstractmethod import matplotlib import matplotlib.pyplot as plt from matplotlib.gridspec import GridSpec import os import sys# 设计模式部分 class PreprocessStrategy(ABC):"&q…
阅读更多...
STM32 控制12VRGB灯带颜色亮度调节，TFTLCD显示

STM32 控制12VRGB灯带颜色亮度调节，TFTLCD显示

接了一个同学的小项目&#xff0c;要实现控制一个实体&#xff0c;控制灯带的亮度为红/绿/蓝/白/黄以及亮度的叠加。 时间要的比较急&#xff0c;要两天实现&#xff0c;因此不能打板&#xff0c;只能采用现有模块拼接。 一. 实施方案 一开始觉得很简单&#xff0c;就是使用五…
阅读更多...
【JJ斗地主-注册安全分析报告】

【JJ斗地主-注册安全分析报告】

前言 由于网站注册入口容易被黑客攻击&#xff0c;存在如下安全问题&#xff1a; 暴力破解密码&#xff0c;造成用户信息泄露短信盗刷的安全问题&#xff0c;影响业务及导致用户投诉带来经济损失&#xff0c;尤其是后付费客户&#xff0c;风险巨大&#xff0c;造成亏损无底洞 …
阅读更多...
《绩效管理》要点总结与分享

《绩效管理》要点总结与分享

目录 绩效管理与目标设定 绩效管理的循环&#xff1a;PDCA 绩效目标的设定要点 绩效设定的工具&#xff1a;SMART法则 绩效跟踪与评估 刻板印象&#xff1a;STAR法 晕轮效应&#xff1a;对比评价法 近因效应&#xff1a;关键事项评估表 绩效面谈 面谈前准备工作 汉堡…
阅读更多...
Microsoft前后端不分离编程新风向：cshtml

Microsoft前后端不分离编程新风向：cshtml

文章目录 什么是CSHTML&#xff1f;基础语法内联表达式代码块控制结构 布局页面_ViewStart.cshtml_Layout.cshtml使用布局 模型绑定强类型视图模型集合 HTML辅助方法基本表单验证 局部视图创建局部视图使用局部视图 高级特性视图组件依赖注入Tag Helpers 性能优化缓存捆绑和压缩…
阅读更多...
【评测】用Flux的图片文本修改的PS效果

【评测】用Flux的图片文本修改的PS效果

【评测】Flux的图片文本修改的PS效果 1. 百度图库找一张有英文的图片 2. 打开https://playground.bfl.ai/image/edit上传图片 3. 输入提示词 “change brarfant to goodbeer” 图片的文字被修改了
阅读更多...
数据库管理-第334期 Oracle Database 23ai测试版RAC部署文档（20250607）

数据库管理-第334期 Oracle Database 23ai测试版RAC部署文档（20250607）

数据库管理334期 2024-06-07 数据库管理-第334期 Oracle Database 23ai测试版RAC部署文档&#xff08;20240607&#xff09;1 环境与安装介质2 操作标准系统配置2.1 关闭防火墙2.2 关闭SELinux2.3 关闭avahi-daemon2.4 时间同步配置 3 存储服务器配置3.1 配置本地yum源3.2 安装…
阅读更多...
AI生成的基于html+marked.js实现的Markdown转html工具，离线使用，可实时预览 [

AI生成的基于html+marked.js实现的Markdown转html工具，离线使用，可实时预览 [

有一个markdown格式的文档&#xff0c;手头只有notepad的MarkdownPanel插件可以预览&#xff0c;但是只能预览&#xff0c;不能直接转换为html文件下载&#xff0c;直接复制预览的内效果又不太好&#xff0c;度娘也能找到很多工具&#xff0c;但是都需要在线使用。所以考虑用AI…
阅读更多...
机器学习：load_predict_project

机器学习：load_predict_project

本文目录&#xff1a; 一、project目录二、utils里的两个工具包&#xff08;一&#xff09;common.py&#xff08;二&#xff09;log.py 三、src文件夹代码&#xff08;一&#xff09;模型训练&#xff08;train.py&#xff09;&#xff08;二&#xff09;模型预测&#xff08;…
阅读更多...
【storage】

【storage】

文章目录 1、RAM and ROM2、DRAM and SRAM2、Flash Memory&#xff08;闪存&#xff09;4、DDR and SPI NOR Flash5、eMMC6、SPI NOR vs SPI NAND vs eMMC vs SD附录——prototype and demo board附录——U盘、SD卡、TF卡、SSD参考 1、RAM and ROM RAM&#xff08;Random Acce…
阅读更多...
JVM 垃圾回收器 详解

JVM 垃圾回收器 详解

垃圾收集器 SerialSerial Old&#xff1a;单线程回收&#xff0c;适用于单核CPU场景ParNewCMS&#xff1a;暂停时间较短&#xff0c;适用于大型互联网应用中与用户交互的部分Paraller ScavengeParallel Old&#xff1a;吞吐量高&#xff0c;适用于后台进行大量数据操作G1&#…
阅读更多...
FreeRTOS任务之深入篇

FreeRTOS任务之深入篇

目录 1.Tick1.1 Tick的概念1.2 Tick与任务调度1.3 Tick与延时函数 2.任务状态2.1 运行状态 (Running)2.2 就绪状态 (Ready)2.3 阻塞状态 (Blocked)5.4 暂停状态 (Suspended)2.5 特殊状态&#xff1a;删除状态 (Deleted)5.6 任务状态转换2.7 实验 3.Delay函数3.1 两个函数3.2 实…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023