C++ 实例 – 求一个数的阶乘（长文解析）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程学习的旅程中，阶乘（Factorial）是一个既经典又重要的概念。它不仅体现了数学与编程的结合，还常被用作理解递归、循环等核心编程思想的典型案例。对于刚接触C++的开发者而言，通过“求一个数的阶乘”这一实例，可以系统地掌握函数设计、算法逻辑以及边界条件处理等关键技能。本文将以“C++ 实例 – 求一个数的阶乘”为核心，从基础概念到代码实现，逐步拆解这一问题的解决过程，并结合实际案例深入探讨其背后的原理与优化方法。

基础概念：阶乘的数学定义与编程意义

什么是阶乘？

阶乘是一个数学运算，用符号“!”表示。例如，5的阶乘写作“5!”，其计算方式为：
5! = 5 × 4 × 3 × 2 × 1 = 120
更一般地，自然数n的阶乘定义为：
n! = n × (n-1) × (n-2) × ... × 1
当n=0时，规定0! = 1。

在编程中，阶乘的计算常被用作练习递归、循环等控制结构的工具。此外，它还出现在组合数学、概率统计等领域，例如计算排列组合的公式：
C(n, k) = n! / (k! × (n−k)!))

阶乘的编程挑战

阶乘看似简单，但实际实现时需注意以下问题：

1. 输入合法性：负数的阶乘无意义，需进行输入验证。
2. 数据溢出：当n较大时（如n>20），结果可能超出整型变量的存储范围。
3. 算法效率：递归与迭代两种实现方式在内存和性能上的差异。

方法一：递归实现

递归的核心思想

递归（Recursion）是一种通过函数调用自身来解决问题的方法。其核心在于将大问题分解为小问题，直到问题足够简单可直接求解。

以阶乘为例，递归的数学表达式为：
n! = n × (n-1)!
当n=1时，递归终止（base case）。

代码示例

#include <iostream>  
using namespace std;  

long long factorial(int n) {  
    // 输入验证：负数直接返回0或提示错误  
    if (n < 0) {  
        cout << "Error: Negative number!" << endl;  
        return 0;  
    }  
    // 递归终止条件  
    if (n == 0 || n == 1) {  
        return 1;  
    }  
    // 递归调用  
    return n * factorial(n - 1);  
}  

int main() {  
    int num;  
    cout << "Enter a number: ";  
    cin >> num;  
    cout << num << "! = " << factorial(num) << endl;  
    return 0;  
}  

递归的执行过程

以计算3!为例，递归调用栈如下：

1. factorial(3) → 计算3 × factorial(2)
2. factorial(2) → 计算2 × factorial(1)
3. factorial(1) → 返回1（base case）
4. 回溯：factorial(2) = 2×1 = 2
5. 回溯：factorial(3) = 3×2 = 6

递归的优缺点

• 优点：代码简洁，逻辑直观，易于理解。
• 缺点：
  • 栈溢出风险：当n很大时（如n=10000），递归调用层级过深可能导致栈内存耗尽。
  • 重复计算：例如计算5!时，需重复计算4!, 3!等，但此问题在阶乘中因递归深度较小，影响有限。

方法二：迭代实现

迭代的核心思想

迭代（Iteration）通过循环结构（如for或while）逐步计算结果，避免了递归的栈开销。其核心是维护一个累积变量，逐步累乘。

代码示例

#include <iostream>  
using namespace std;  

long long factorial(int n) {  
    if (n < 0) {  
        cout << "Error: Negative number!" << endl;  
        return 0;  
    }  
    long long result = 1;  
    for (int i = 2; i <= n; ++i) {  
        result *= i;  
    }  
    return result;  
}  

int main() {  
    // 同上  
}  

迭代的执行过程

以计算4!为例：

1. 初始化result = 1
2. 循环i=2 → result = 1 × 2 = 2
3. 循环i=3 → result = 2 × 3 = 6
4. 循环i=4 → result = 6 × 4 = 24

迭代的优缺点

• 优点：
  • 内存效率高：无需维护递归调用栈，适合处理大数值。
  • 无栈溢出风险：只要循环条件设置合理，可处理更大的n值。
• 缺点：代码逻辑略显繁琐，对数学表达式不够直观。

关键知识点详解：输入验证与数据溢出

输入验证的重要性

在实际编程中，用户可能输入负数或非整数，此时需通过条件判断拦截错误输入。例如：

if (n < 0) {  
    cerr << "Error: Factorial is undefined for negative numbers." << endl;  
    return -1; // 或抛出异常  
}  

数据溢出的应对策略

当n较大时（如n=20时，20! ≈ 2.4e18），long long类型（64位）仍可存储，但超过20后会溢出。此时可考虑以下方法：

1. 使用大整数库：如C++的boost::multiprecision或自定义高精度计算类。
2. 返回字符串形式的结果：逐位计算并存储为字符串。

示例：用字符串模拟大数阶乘

#include <string>  
string multiply(const string& num, int multiplier) {  
    string result;  
    int carry = 0;  
    for (auto c : num) {  
        int temp = (c - '0') * multiplier + carry;  
        result.push_back(temp % 10 + '0');  
        carry = temp / 10;  
    }  
    while (carry > 0) {  
        result.push_back(carry % 10 + '0');  
        carry /= 10;  
    }  
    return result;  
}  

string factorial(int n) {  
    string result = "1";  
    for (int i = 2; i <= n; ++i) {  
        result = multiply(result, i);  
    }  
    return result;  
}  

进阶优化：尾递归与算法效率分析

尾递归优化

尾递归（Tail Recursion）是指递归调用是函数的最后一个操作，此时编译器可优化为迭代形式，避免栈溢出。例如：

long long factorial_helper(int n, long long acc = 1) {  
    if (n == 0) return acc;  
    return factorial_helper(n - 1, acc * n); // 尾递归形式  
}  

long long factorial(int n) {  
    return factorial_helper(n);  
}  

但需注意：C++标准未强制要求编译器优化尾递归，实际效果依赖编译器（如GCC的-O2优化选项）。

算法效率对比

实战案例：综合实现与测试

综合代码示例（迭代+输入验证+大数支持）

#include <iostream>  
#include <string>  
using namespace std;  

// 基础阶乘（适合n≤20）  
long long basic_factorial(int n) {  
    if (n < 0) throw invalid_argument("Negative input");  
    long long res = 1;  
    for (int i = 2; i <= n; ++i) res *= i;  
    return res;  
}  

// 大数阶乘（字符串模拟）  
string big_factorial(int n) {  
    string num = "1";  
    for (int i = 2; i <= n; ++i) {  
        int carry = 0;  
        for (size_t j = 0; j < num.size(); ++j) {  
            int temp = (num[j] - '0') * i + carry;  
            num[j] = (temp % 10) + '0';  
            carry = temp / 10;  
        }  
        while (carry > 0) {  
            num.push_back((carry % 10) + '0');  
            carry /= 10;  
        }  
    }  
    return num;  
}  

int main() {  
    int num;  
    cout << "Enter a number (<=20 for basic, >20 for big): ";  
    cin >> num;  
    try {  
        if (num <= 20) {  
            cout << num << "! = " << basic_factorial(num) << endl;  
        } else {  
            cout << num << "! = " << big_factorial(num) << endl;  
        }  
    } catch (const exception& e) {  
        cerr << "Error: " << e.what() << endl;  
    }  
    return 0;  
}  

测试用例

总结与扩展

通过本文的讲解，我们系统学习了“C++ 实例 – 求一个数的阶乘”的多种实现方法，包括递归、迭代、大数模拟等。这些方法不仅展示了编程逻辑的多样性，还揭示了算法设计中效率与可读性权衡的哲学。

对于进一步学习，建议读者尝试以下方向：

1. 算法优化：探索更高效的阶乘计算方法（如分治算法）。
2. 异常处理：在代码中使用C++的try-catch机制完善错误处理。
3. 数学应用：将阶乘用于组合数学问题（如排列、组合的计算）。

编程的本质是“将复杂问题拆解为简单步骤”，而阶乘这一实例正是这一思想的最佳实践之一。希望本文能为你的编程之路提供扎实的基础与启发！