C语言求平方根函数怎么写｜完整实现与深度解析

鲁棒版强化了边界处理与错误检查，适合实际项目集成：

include <stdio.h>
include <math.h>
include <float.h>
double my_sqrt(double x) {
    // 处理负数：返回NaN并打印错误
    if (x < 0.0) {
        fprintf(stderr, "错误：负数 %.6f 没有实数平方根n", x);
        return NAN;
    }
    // 处理零值
    if (x == 0.0) {
        return 0.0;
    }
    // 极小值处理：避免除零风险
    if (x < DBL_MIN) {
        return 0.0;
    }
    // 初始猜测：对大数使用更优的初始值
    double guess = x;
    if (x > 1.0) {
        guess = x / 2.0; // 大数初始值更靠近真实根
    }
    int iter = 0;
    const int max_iter = 50;
    const double epsilon = 1e-15;
    while (iter < max_iter) {
        double new_guess = (guess + x / guess) / 2.0;
        // 使用相对误差避免小数精度问题
        if (fabs(new_guess - guess) < epsilon  fabs(new_guess)) {
            return new_guess;
        }
        guess = new_guess;
        iter++;
    }
    // 达到最大迭代次数，返回近似值
    fprintf(stderr, "警告：迭代达到上限，返回近似值 %.10fn", guess);
    return guess;
}
int main() {
    double test_values[] = {0.0, 1.0, 2.0, 16.0, 10000.0, -4.0};
    int n = sizeof(test_values) / sizeof(double);
    printf("=== 鲁棒版平方根函数测试 ===nn");
    for (int i = 0; i < n; i++) {
        double val = test_values[i];
        double result = my_sqrt(val);
        if (isnan(result)) {
            printf("输入：%.2f → 输出：NaN (负数无实根)n", val);
        } else {
            printf("输入：%.2f → 结果：%.10f (误差：%.2e)n",
                   val, result, fabs(result - sqrt(val)));
        }
    }
    return 0;
}

输出结果：

=== 鲁棒版平方根函数测试 ===
输入：0.00 → 输出：0.0000000000 (误差：0.00e+00)
输入：1.00 → 输出：1.0000000000 (误差：0.00e+00)
输入：2.00 → 输出：1.4142135624 (误差：2.22e-16)
输入：16.00 → 输出：4.0000000000 (误差：0.00e+00)
输入：10000.00 → 输出：100.0000000000 (误差：0.00e+00)
错误：负数 -4.000000 没有实数平方根
输入：-4.00 → 输出：nan (负数无实根)

优化版针对高频调用场景，引入位运算与查表预处理：

include <stdio.h>
include <stdint.h>
static inline double fast_sqrt(double x) {
    if (x <= 0.0) return x;
    // 关键优化：通过位操作获取初始猜测值
    // 将double视为uint64_t，提取指数部分
    uint64_t xi = reinterpret_cast<uint64_t>(const_cast<double>(static_cast<const double>(&x)));
    // 指数右移1位（相当于开平方），并添加偏置校正
    xi = (xi >> 1) + (0x1FF8000000000000ULL - 0x3FF0000000000000ULL >> 1);
    double guess = reinterpret_cast<double>(&xi);
    // 牛顿迭代3次达到double精度
    guess = (guess + x / guess) / 2.0;
    guess = (guess + x / guess) / 2.0;
    guess = (guess + x / guess) / 2.0;
    return guess;
}
int main() {
    double test_values[] = {2.0, 123.456, 1e10, 1e-10, 0.0001};
    printf("=== 高性能版测试（3次迭代）===nn");
    printf("%-12s %-18s %-18s %-15sn",
           "输入值", "my_sqrt结果", "库函数sqrt", "相对误差");
    printf("%-12s %-18s %-18s %-15sn", "------", "-----------", "-----------", "---------");
    for (int i = 0; i < 5; i++) {
        double val = test_values[i];
        double result = fast_sqrt(val);
        double ref = sqrt(val);
        double rel_err = fabs(result - ref) / ref;
        printf("%-12.6f %-18.10f %-18.10f %-15.2en",
               val, result, ref, rel_err);
    }
    return 0;
}

性能对比实测：

❓问题：为什么结果总有微小误差？

根本原因：IEEE 754 浮点数是有限精度的近似表示。

// 常见误差现象
double x = sqrt(2.0);  // 实际值：1.4142135623730951
printf("%.20fn", x); // 输出：1.41421356237309514547
printf("%.20fn", xx); // 输出：2.00000000000000000000（看似正确）
if (xx == 2.0) {
    printf("相等！");  // 但这里可能不执行！
}

解决方案：

• 用 fabs(a - b) < 1e-9 替代 a == b
• 输出时用 %.6f 控制显示位数
• 关键计算用 long double 提升精度

❓问题：负数/零值输入会怎样？

标准库行为：

自定义实现建议：

if (x < 0.0) {
    fprintf(stderr, "错误：输入 %.6f 为负数n", x);
    return NAN;
}

❓问题：性能瓶颈主要在哪里？

实测数据（100万次调用）：

终极优化：直接用硬件指令（性能最优）

❓问题：如何验证实现正确性？

测试策略：

1. 基础用例：0, 1, 4, 9, 16, 25
2. 边界用例：DBL_MIN, DBL_MAX, Inf, NaN
3. 精度用例：$sqrt{2}, sqrt{3}, pi$
4. 压力测试：1000万次随机数（0~1e10）
5. 对比测试：与标准库结果误差分析

示例测试代码：

for (int i = 0; i < 1000000; i++) {
    double x = (double)rand() / RAND_MAX  1e10;
    double my = my_sqrt(x);
    double ref = sqrt(x);
    if (fabs(my - ref) > 1e-10  fabs(ref)) {
        printf("失败：x=%.6f, my=%.10f, ref=%.10fn", x, my, ref);
        break;
    }
}