【安全函数】幂运算进阶：sqrt_s()与pow_s()解析

// 功能：计算非负浮点数的平方根，执行输入合法性校验
// 参数：
//   x：待计算平方根的输入值（需为非负）
//   result：输出参数，指向存储计算结果的浮点数地址（非NULL）
// 返回值：
//   0：运算成功，result存储有效结果
//   -1：输入错误（x<0或result为NULL）
int sqrt_s(double x, double* result);

// 功能：计算base的exp次幂，执行全场景输入合法性校验
// 参数：
//   base：幂运算的底数
//   exp：幂运算的指数
//   result：输出参数，指向存储计算结果的浮点数地址（非NULL）
// 返回值：
//   0：运算成功，result存储有效结果
//   -1：输入错误（含多种非法场景，详见注意事项）
int pow_s(double base, double exp, double* result);

函数 sqrt_s(输入参数 x: 双精度浮点数, 输出参数 result: 双精度浮点数指针) -> 整数:
    // 第一步：校验输出参数有效性（避免空指针解引用）
    如果 result 等于 NULL:
        返回 -1  // 输出参数无效
    // 第二步：校验输入值定义域（负数无实数平方根）
    如果 x 小于 0.0:
        返回 -1  // 输入值超出定义域
    // 第三步：调用标准库函数执行核心计算
    *result = 标准库 sqrt(x)
    // 第四步：返回成功状态
    返回 0

函数 pow_s(输入参数 base: 双精度浮点数, 输入参数 exp: 双精度浮点数, 输出参数 result: 双精度浮点数指针) -> 整数:
    // 校验1：输出参数非空校验
    如果 result 等于 NULL:
        返回 -1
    // 校验2：负数底数的指数合法性（仅允许整数指数）
    如果 base 小于 0.0:
        // 判断指数是否为整数（允许微小浮点数误差，如2.0000001视为整数）
        如果 绝对值(exp - 四舍五入(exp)) 大于 1e-9:
            返回 -1  // 负数底数不支持非整数指数
    // 校验3：0底数的指数合法性（仅允许正指数）
    如果 base 等于 0.0:
        如果 exp 小于等于 0.0:
            返回 -1  // 0的非正指数无意义
    // 校验4：指数的有效性（排除NaN和无穷大）
    如果 是NaN(exp) 或者 是无穷大(exp):
        返回 -1
    // 核心计算：调用标准库pow()执行运算
    *result = 标准库 pow(base, exp)
    // 额外校验：计算结果是否为NaN（应对极端场景）
    如果 是NaN(*result):
        返回 -1
    返回 0

// 错误用法：忽略返回值
double res;
sqrt_s(-1.0, &res);  // 返回-1但未处理
printf("结果：%f\n", res);  // res值未定义，可能输出随机数

// 正确用法：检查返回值
double res;
int status = sqrt_s(input, &res);
if (status != 0) {
    printf("错误：输入不合法（%d）\n", status);
    // 执行错误处理：重试、提示用户、日志记录等
} else {
    printf("结果：%f\n", res);
}

// 正确做法：初始化输出参数
double res = 0.0;  // 初始化默认值
int status = pow_s(-2.0, 0.5, &res);
if (status != 0) {
    printf("错误：非法运算\n");
    // 此时res仍为0.0，可作为默认值使用
} else {
    printf("结果：%f\n", res);
}

double res;
pow_s(2.0, 0.5, &res);  // 计算√2，理论值约1.41421356

// 错误用法：直接用==对比
if (res == 1.41421356) { ... }  // 可能因精度误差返回false

// 正确用法：容差对比（允许1e-6的误差）
if (fabs(res - 1.41421356) < 1e-6) { ... }  // 正确判断相等

#include <stdio.h>
#include <math.h>
#include <time.h>

// 安全平方根函数实现
int sqrt_s(double x, double* result) {
    if (result == NULL) {
        // 记录错误日志（简化版：打印时间+错误信息）
        time_t now = time(NULL);
        printf("[%s] 错误：输出参数为NULL\n", ctime(&now));
        return -1;
    }
    if (x < 0.0) {
        time_t now = time(NULL);
        printf("[%s] 错误：输入为负数（x=%.2f）\n", ctime(&now), x);
        return -1;
    }
    *result = sqrt(x);
    return 0;
}

int main() {
    double input, res;
    printf("请输入一个非负数，将计算其平方根：");
    // 读取用户输入并判断是否有效
    if (scanf("%lf", &input) != 1) {
        printf("错误：输入不是合法数字\n");
        return 1;
    }
    
    // 调用安全函数并处理结果
    int status = sqrt_s(input, &res);
    if (status == 0) {
        printf("计算成功：%.2f的平方根为%.4f\n", input, res);
    } else {
        printf("计算失败，错误码：%d\n", status);
        return 1;
    }
    return 0;
}

请输入一个非负数，将计算其平方根：25
计算成功：25.00的平方根为5.0000

请输入一个非负数，将计算其平方根：-9
[Wed Oct 16 14:30:00 2024
] 错误：输入为负数（x=-9.00）
计算失败，错误码：-1

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

// 辅助函数：判断浮点数是否为整数（含精度容错）
bool is_integer(double x) {
    return fabs(x - round(x)) < 1e-9;
}

// 安全幂函数实现
int pow_s(double base, double exp, double* result) {
    if (result == NULL) return -1;
    // 负数底数校验
    if (base < 0.0 && !is_integer(exp)) {
        printf("错误：负数底数（%.2f）不支持非整数指数（%.2f）\n", base, exp);
        return -1;
    }
    // 0底数校验
    if (base == 0.0 && exp <= 0.0) {
        printf("错误：0底数不支持非正指数（%.2f）\n", exp);
        return -1;
    }
    // 指数有效性校验
    if (isnan(exp) || isinf(exp)) {
        printf("错误：指数为NaN或无穷大\n");
        return -1;
    }
    // 核心计算
    *result = pow(base, exp);
    // 结果校验
    if (isnan(*result)) {
        printf("错误：计算结果为NaN\n");
        return -1;
    }
    return 0;
}

int main() {
    // 电机电压测试用例（含合法与非法场景）
    double voltage_cases[] = {10.0, 20.0, -5.0, 0.0, 15.0};
    double exp = 1.2;  // 固定指数：转速与电压的关系系数
    int case_count = sizeof(voltage_cases) / sizeof(voltage_cases[0]);
    
    for (int i = 0; i < case_count; i++) {
        double volt = voltage_cases[i];
        double speed;  // 转速（单位：r/min）
        int status = pow_s(volt, exp, &speed);
        
        printf("测试用例%d：电压=%.2fV → ", i+1, volt);
        if (status == 0) {
            printf("转速=%.1fr/min\n", speed);
        } else {
            printf("计算失败\n");
        }
    }
    return 0;
}

测试用例1：电压=10.00V → 转速=15.8r/min
测试用例2：电压=20.00V → 转速=33.1r/min
测试用例3：电压=-5.00V → 错误：负数底数（-5.00）不支持非整数指数（1.20）
计算失败
测试用例4：电压=0.00V → 错误：0底数不支持非正指数（1.20）
计算失败
测试用例5：电压=15.00V → 转速=26.3r/min

int my_sqrt(int x) {
    // 边界处理：x=0或x=1时，平方根为自身
    if (x == 0 || x == 1) {
        return x;
    }
    // 二分查找范围：low=0，high=x/2（优化：x≥2时平方根≤x/2）
    int low = 0, high = x / 2;
    int result = 0;
    while (low <= high) {
        int mid = low + (high - low) / 2;  // 避免溢出
        long long square = (long long)mid * mid;  // 防止mid²溢出
        if (square == x) {
            return mid;  // 完全平方数，直接返回
        } else if (square < x) {
            result = mid;  // 记录当前可能的最大整数结果
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return result;
}