异常教程

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+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程学习的旅程中，实现两个数相加看似简单，却是理解语言核心机制的重要起点。无论是编程初学者还是希望巩固基础的开发者，通过这个实例可以逐步掌握变量、函数、运算符等基础概念。本文将以“C++ 实例 – 实现两个数相加”为线索，从代码实现到进阶优化，逐步展开讲解，帮助读者构建扎实的编程思维。

一、基础概念：变量、函数与运算符

1.1 变量与数据类型

在 C++ 中，变量是存储数据的容器。例如，int a = 5; 声明了一个名为 a 的整型变量，并赋值为 5。不同数据类型（如 int、double、char）决定了变量的存储空间和取值范围。
形象比喻：

可以将变量想象为一个带标签的储物柜，标签（变量名）标明了柜子的用途，而柜子的大小（数据类型）决定了能存放什么物品（数值范围）。

1.2 函数：代码的复用单元

函数是封装特定功能的代码块。例如，定义一个名为 add 的函数，输入两个数并返回它们的和：

int add(int a, int b) {  
    return a + b;  
}

关键点：

  • 返回类型（int）：函数执行后输出的数据类型。
  • 参数列表（int a, int b）：函数接收的输入值。
  • 函数体：包含具体的操作逻辑。

1.3 运算符：操作数据的工具

C++ 提供了丰富的运算符，其中加法运算符 + 是最基础的。例如：

int result = 3 + 4; // result 的值为 7

运算符可以作用于变量或直接值，执行算术、逻辑、位等操作。

二、基础实现：简单加法函数

2.1 最简代码示例

以下是一个实现两个整数相加的完整 C++ 程序：

#include <iostream>  

int add(int a, int b) {  
    return a + b;  
}  

int main() {  
    int num1 = 5;  
    int num2 = 7;  
    int sum = add(num1, num2);  
    std::cout << "和为: " << sum << std::endl;  
    return 0;  
}

代码解析：

  1. #include <iostream>：包含输入输出流库，用于 std::cout。
  2. add 函数接收两个整数，返回它们的和。
  3. main 函数是程序入口，定义变量 num1、num2 并调用 add。
  4. std::cout 输出结果到控制台。

2.2 输入动态数值

为了让程序更灵活，可以允许用户输入数值：

int main() {  
    int a, b;  
    std::cout << "请输入第一个数: ";  
    std::cin >> a;  
    std::cout << "请输入第二个数: ";  
    std::cin >> b;  
    int sum = add(a, b);  
    std::cout << "和为: " << sum << std::endl;  
    return 0;  
}

关键函数：

  • std::cin：从标准输入（键盘）读取数据，需确保输入类型与变量匹配。

三、进阶方法：指针与引用

3.1 指针实现

通过指针传递地址，可以修改原始变量的值：

void add_with_pointers(int* a, int* b, int* result) {  
    *result = *a + *b;  
}  

int main() {  
    int x = 10, y = 20, sum = 0;  
    add_with_pointers(&x, &y, &sum);  
    std::cout << "结果: " << sum << std::endl; // 输出 30  
    return 0;  
}

指针原理：

  • &x 表示变量 x 的内存地址。
  • *a 表示解引用指针，访问该地址存储的值。
    比喻：

指针就像快递单上的地址，通过地址可以找到对应的“包裹”（数值）。

3.2 引用简化代码

引用（&）是变量的别名，避免了指针的复杂性：

void add_with_references(int a, int b, int& result) {  
    result = a + b;  
}  

int main() {  
    int x = 5, y = 15;  
    int total;  
    add_with_references(x, y, total);  
    std::cout << "总和: " << total << std::endl; // 输出 20  
    return 0;  
}

优势：

  • 直接使用变量名，无需解引用操作符 *。
  • 避免空指针或地址错误。

四、泛型编程：模板函数

4.1 支持多种数据类型

通过模板（Template），函数可以处理不同数据类型（如 int、double）：

template<typename T>  
T add_generic(T a, T b) {  
    return a + b;  
}  

int main() {  
    int i = add_generic<int>(3, 4); // 7  
    double d = add_generic<double>(2.5, 3.6); // 6.1  
    return 0;  
}

模板机制：

  • template<typename T> 声明一个泛型函数，T 是占位符类型。
  • 调用时显式指定类型，或由编译器推导（C++11 起支持）。

4.2 混合类型相加

若需兼容不同数据类型（如 int 和 double），可扩展模板参数：

template<typename T, typename U>  
auto add_mixed(T a, U b) -> decltype(a + b) {  
    return a + b;  
}  

int main() {  
    auto result = add_mixed(5, 3.2); // 返回 double 类型 8.2  
    return 0;  
}

关键点：

  • decltype(a + b) 自动推导返回类型。
  • auto 关键字简化了类型声明。

五、错误处理与程序健壮性

5.1 输入验证

防止用户输入非数值字符：

int get_number() {  
    int num;  
    while (true) {  
        std::cout << "请输入一个整数: ";  
        std::cin >> num;  
        if (std::cin.fail()) { // 输入无效  
            std::cin.clear();  
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');  
            std::cout << "输入错误，请重新输入！\n";  
        } else {  
            return num;  
        }  
    }  
}

逻辑说明：

  • 循环直到输入有效。
  • cin.fail() 检测输入是否合法。
  • cin.ignore() 清除无效输入。

5.2 处理溢出风险

当整数相加大于 INT_MAX 时，结果会溢出。可以添加检查逻辑：

#include <climits>  

int safe_add(int a, int b) {  
    if ((b > 0 && a > INT_MAX - b) || (b < 0 && a < INT_MIN - b)) {  
        throw std::overflow_error("溢出！");  
    }  
    return a + b;  
}  

int main() {  
    try {  
        int result = safe_add(1000000000, 1000000000);  
        std::cout << "结果: " << result << std::endl;  
    } catch (const std::exception& e) {  
        std::cerr << "错误: " << e.what() << std::endl;  
    }  
    return 0;  
}

异常处理：

  • throw 抛出异常，try-catch 捕获并处理。
  • INT_MAX 和 INT_MIN 定义于 <climits>。

六、扩展应用：计算器程序

6.1 综合示例

结合输入、运算和异常处理，构建一个交互式计算器：

#include <iostream>  
#include <limits>  

int main() {  
    while (true) {  
        std::cout << "请输入两个数（输入 q 退出）:\n";  
        int a, b;  
        std::cin >> a >> b;  
        if (std::cin.fail()) {  
            std::cin.clear();  
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');  
            std::cout << "无效输入！\n";  
            continue;  
        }  
        try {  
            int sum = safe_add(a, b);  
            std::cout << "和为: " << sum << std::endl;  
        } catch (const std::exception& e) {  
            std::cerr << e.what() << std::endl;  
        }  
    }  
    return 0;  
}

功能特点：

  • 循环运行，直到用户主动退出。
  • 支持输入验证和溢出检测。

七、性能优化与内存管理

7.1 使用常量引用

避免函数参数的拷贝开销：

int add(const int& a, const int& b) {  
    return a + b;  
}

优势：

  • 对于大对象（如结构体）避免复制，提升效率。
  • const 修饰符确保参数不可修改。

7.2 内联函数

通过 inline 关键字减少函数调用开销：

inline int add(int a, int b) {  
    return a + b;  
}

原理：

  • 编译器将函数代码直接嵌入调用处，省去跳转时间。
  • 对于简单函数（如加法）效果显著。

八、常见问题与解答

8.1 为什么需要 #include <iostream>？

答：C++ 标准库通过头文件提供功能。<iostream> 包含 std::cout 和 std::cin 的定义，缺少它会导致编译错误。

8.2 指针与引用有什么区别？

答：
| 特性 | 指针 | 引用 |
|--------------|-------------------------------|-------------------------------|
| 声明 | int* ptr = &var; | int& ref = var; |
| 初始化 | 可以指向 nullptr | 必须初始化为有效变量 |
| 灵活性 | 可重新指向其他变量 | 绑定后不可更改目标变量 |

8.3 模板函数是否会影响编译时间？

答：是的。模板会生成针对不同类型的代码实例，导致编译时间增加。但对最终程序的运行效率无负面影响。

结论

从简单函数到泛型编程，从基础语法到内存优化，“C++ 实例 – 实现两个数相加”这一看似简单的任务，实际上涵盖了编程的核心知识。通过逐步深入的实践，读者不仅能掌握基本的算术运算，还能理解函数设计、数据类型、异常处理等进阶概念。建议读者在阅读后动手编写代码，尝试修改参数类型、添加新功能（如减法或乘法），从而真正内化所学知识。编程的本质是不断实践与思考，愿每位开发者都能从中找到乐趣与成长。

最新发布

查看更多文章