C++程序设计

一、C++输入与输出详解

1.1核心基础：<iostream>头文件

C++的标准输入输出首先需要包含<iostream> 头文件，它定义了标准输入流（std::cin)、标准输出流（std::cout）等核心对象。

1.1.1标准输出：std::cout

std::cout用于将数据输出到标准输出设备，配合输出运算符<<（称为"插入运算符"）使用，可以连续拼接输出多个数据

#include <iostream>  // 包含标准输入输出头文件

// 推荐使用 std 命名空间（或按需使用 std:: 前缀），避免重复写 std::
using namespace std;

int main() {
    // 单个数据输出
    cout << "Hello, C++ I/O!" << endl;  // endl：换行并刷新输出缓冲区
    
    // 多个数据连续拼接输出（支持不同数据类型）
    int a = 100;
    double b = 3.14159;
    char c = 'A';
    cout << "整数a：" << a 
         << "，浮点数b：" << b 
         << "，字符c：" << c << endl;
    
    return 0;
}

endl：作用是换行+刷新缓冲区，确保数据立即显示在控制台；也可以用转义字符\n仅实现换行（效率更高，无需刷新缓冲区）。

1.1.2标准输入std::cin

std::cin用于从标准输入设备读取数据，配合输入运算符>>（称为"提取运算符"）使用，可连续读取多个数据。

#include <iostream>
using namespace std;

int main() {
    // 单个变量输入
    int num;
    cout << "请输入一个整数：";
    cin >> num;  // 提取键盘输入的整数，存入变量num
    cout << "你输入的整数是：" << num << endl;
    
    // 多个变量连续输入（支持不同数据类型，用空格/回车/制表符分隔输入）
    string name;
    int age;
    double score;
    cout << "请输入你的姓名、年龄、成绩（用空格分隔）：";
    cin >> name >> age >> score;
    cout << "姓名：" << name << "，年龄：" << age << "，成绩：" << score << endl;
    
    return 0;
}

分隔符：cin用空白符（空格、回车、制表符）作为输入数据的分隔符，输入多个数据时，无需严格对应代码中的换行，只需要用空白字符分隔即可。

数据匹配：输入的数据类型必须与接受变量的类型匹配，否则会导致输入失败（变量值为默认垃圾值，后续输入也会受影响）。

自动跳过空白：cin>>会自动跳过输入开头的空白字符，直接读取有效数据。

1.2格式化输入输出

（1)操纵符（<iomanip>头文件）：更简洁，推荐使用；

（2）使用cout/cin的成员函数：功能更强大。语法稍复杂。

#include <iostream>
#include <iomanip>  // 包含格式化操纵符的头文件
using namespace std;

int main() {
    double pi = 3.1415926;
    
    // 保留2位小数（四舍五入）
    cout << "保留2位小数的π：" << fixed << setprecision(2) << pi << endl;
    
    // 设置输出宽度为10，右对齐（默认），不足补空格
    cout << "设置宽度10：" << setw(10) << pi << endl;
    
    // 左对齐，不足补0
    cout << "左对齐+补0：" << left << setfill('0') << setw(10) << pi << endl;
    
    return 0;
}

二、程序设计的基本结构

2.1顺序结构

C++ 顺序结构 是指程序在执行时，按照语句书写的先后顺序，从上到下、依次逐条执行，没有跳转、没有分支、没有重复，执行过程是线性的、单向的，执行完一条语句后自动执行下一条语句，直到所有语句执行完毕。

语句1; // 第一步：执行语句1

语句2; // 第二步：执行完语句1后，自动执行语句2

语句3; // 第三步：执行完语句2后，自动执行语句3

......

语句n; // 第n步：执行完语句n-1后，自动执行语句n，程序片段结束

#include <iostream>  // 包含输入输出流头文件，用于cin和cout操作
using namespace std; // 使用标准命名空间，避免重复书写std::

int main() {
    // 步骤1：变量定义（顺序结构第一步：声明需要使用的变量）
    int a, b;        // 声明两个整型变量，用于存储输入的两个整数
    int sum, product;// 声明两个整型变量，用于存储和与积

    // 步骤2：数据输入（顺序结构第二步：获取用户输入的数据）
    cout << "请输入第一个整数：";
    cin >> a;        // 接收用户输入的第一个整数，存入变量a
    cout << "请输入第二个整数：";
    cin >> b;        // 接收用户输入的第二个整数，存入变量b

    // 步骤3：数据处理（顺序结构第三步：对输入的数据进行计算处理）
    sum = a + b;     // 计算a和b的和，存入sum变量
    product = a * b; // 计算a和b的积，存入product变量

    // 步骤4：结果输出（顺序结构第四步：输出处理后的结果）
    cout << "两个数的和为：" << sum << endl;
    cout << "两个数的积为：" << product << endl;

    return 0; // 程序正常结束，返回0
}

2.2选择结构

选择结构（又称分支结构），程序执行到该结构时，会先对一个或多个条件进行判断，条件为 "真"（非 0 值，通常用Ture表示）时执行某一段代码，条件为 "假"（0 值，通常用False表示）时执行另一段代码（或不执行额外代码），实现 "按需执行" 的分支逻辑。

C++ 中选择结构主要分为两类：if系列（单分支、双分支、多分支、嵌套）和switch语句(多分支匹配）。

2.2.1if系列选择结构

if系列是 C++ 中最灵活、应用最广泛的选择结构，支持简单条件判断，也支持复杂的多条件嵌套，无需额外的匹配关键字，直接基于条件真假分支。

（1）单分支if语句（满足条件才执行）

if (条件表达式) {

// 条件为真（非0）时，执行的语句块

语句1;

语句2;

......

}

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入你的考试分数：";
    cin >> score;

    // 单分支if：分数大于等于60，提示及格
    if (score >= 60) {
        cout << "恭喜你，考试及格！" << endl;
        cout << "可以进入下一阶段学习~" << endl;
    }

    // 无论是否满足条件，都会执行该语句（跳出if结构后的顺序代码）
    cout << "分数查询完毕，感谢使用！" << endl;
    return 0;
}

（2）双分支if-else语句（二选一执行）

if (条件表达式) {

// 条件为真时，执行的语句块（分支1）

语句块1;

} else {

// 条件为假时，执行的语句块（分支2）

语句块2;

}

else不能单独使用，必须紧跟在if语句之后，且二者共享同一个条件判断结果，分支 1 和分支 2 必定只会执行其中一个。

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入你的考试分数：";
    cin >> score;

    // 双分支if-else：及格/不及格二选一
    if (score >= 60) {
        cout << "恭喜你，考试及格！" << endl;
    } else {
        cout << "很遗憾，考试不及格，需要补考~" << endl;
    }

    cout << "分数查询完毕，感谢使用！" << endl;
    return 0;
}

（3）多分支if-else if-else 语句

if (条件表达式1) {

// 条件1为真时，执行的语句块

语句块1;

} else if (条件表达式2) {

// 条件1为假、条件2为真时，执行的语句块

语句块2;

} else if (条件表达式3) {

// 条件1、2为假、条件3为真时，执行的语句块

语句块3;

}

......

else {

// 所有前面的条件都为假时，执行的语句块（可选，作为默认分支）

语句块n;

}

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入你的考试分数（0-100）：";
    cin >> score;

    // 多分支if-else if-else：评定分数等级
    if (score >= 90 && score <= 100) {
        cout << "你的成绩等级为：优秀（A）" << endl;
    } else if (score >= 80 && score < 90) {
        cout << "你的成绩等级为：良好（B）" << endl;
    } else if (score >= 70 && score < 80) {
        cout << "你的成绩等级为：中等（C）" << endl;
    } else if (score >= 60 && score < 70) {
        cout << "你的成绩等级为：及格（D）" << endl;
    } else if (score >= 0 && score < 60) {
        cout << "你的成绩等级为：不及格（E）" << endl;
    } else {
        cout << "你输入的分数无效，请输入0-100之间的整数！" << endl;
    }

    return 0;
}

（4）嵌套if语句

if (外层条件表达式) {

// 外层条件为真时执行

if (内层条件表达式) {

// 内层条件为真时执行

内层语句块1;

} else {

// 内层条件为假时执行

内层语句块2;

}

} else {

// 外层条件为假时执行

外层语句块2;

}

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入你的考试分数（0-100）：";
    cin >> score;

    if (score >= 60 && score <= 100) {
        cout << "恭喜你，考试及格！" << endl;
        // 嵌套if：及格范围内再细分等级
        if (score >= 90) {
            cout << "且成绩为优秀，值得表扬！" << endl;
        } else {
            cout << "继续努力，有望冲击优秀！" << endl;
        }
    } else if (score >= 0 && score < 60) {
        cout << "很遗憾，考试不及格，需要补考~" << endl;
    } else {
        cout << "你输入的分数无效！" << endl;
    }

    return 0;
}

2.2.2switch语句

switch (表达式) {

case 常量值1:

// 表达式结果等于常量值1时，执行的语句块

语句块1; break; // 跳出switch结构，避免"穿透"到下一个case

case 常量值2:

// 表达式结果等于常量值2时，执行的语句块

语句块2; break;

......

case 常量值n:

语句块n;

break;

、 default: // 可选，匹配所有case之外的情况（默认分支）

默认语句块;

break;

}

#include <iostream>
using namespace std;

int main() {
    int menuNum;
    cout << "===== 简易菜单 =====" << endl;
    cout << "1. 查看个人信息" << endl;
    cout << "2. 修改密码" << endl;
    cout << "3. 退出程序" << endl;
    cout << "请输入你的选择（1-3）：";
    cin >> menuNum;

    // switch语句：匹配菜单编号
    switch (menuNum) {
        case 1:
            cout << "正在查询个人信息...（功能待实现）" << endl;
            break;
        case 2:
            cout << "正在进入密码修改界面...（功能待实现）" << endl;
            break;
        case 3:
            cout << "程序即将退出，感谢使用！" << endl;
            break;
        default:
            cout << "你输入的菜单编号无效，请重新输入！" << endl;
            break;
    }

    return 0;
}

2.3循环结构

2.3.1for循环

for循环是一种结构化、紧凑的循环形式，非常适合已知循环次数的场景。

for (初始化表达式; 条件判断表达式; 更新表达式) {

循环体语句; // 满足条件时执行的代码块（单条语句可省略大括号）

}

#include <iostream>
using namespace std;

int main() {
    // 初始化：i=1；条件：i<=10；更新：i自增1
    for (int i = 1; i <= 10; ++i) {
        cout << i << " "; // 输出：1 2 3 4 5 6 7 8 9 10
    }
    return 0;
}

2.3.2while循环

while循环是一种先判断、后执行的循环，语法简洁，适合未知循环次数的场景。

while (条件判断表达式) {

循环体语句; // 条件为true时执行

}

#include <iostream>
using namespace std;

int main() {
    int i = 1; // 先初始化循环变量（外部初始化）
    // 条件：i<=10
    while (i <= 10) {
        cout << i << " "; // 输出：1 2 3 4 5 6 7 8 9 10
        ++i; // 修改循环变量（避免死循环）
    }
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int num;
    cout << "请输入数字（输入0退出）：" << endl;
    while (true) { // 无限循环（条件恒为true）
        cin >> num;
        if (num == 0) {
            break; // 跳出循环
        }
        cout << "你输入的是：" << num << endl;
    }
    return 0;
}

不知道循环需要执行多少次，只知道循环终止的条件（如用户输入指定值退出、读取文件直到末尾）。

2.3.3do-while循环

do-while循环是一种先执行、后判断的循环，保证循环体至少执行一次。

do {

循环体语句; // 先执行一次

} while (条件判断表达式); // 注意末尾有分号

#include <iostream>
using namespace std;

int main() {
    int i = 1; // 外部初始化循环变量
    do {
        cout << i << " "; // 先执行：即使i>10，也会执行一次
        ++i; // 修改循环变量
    } while (i <= 10); // 后判断：i<=10时继续循环
    // 输出：1 2 3 4 5 6 7 8 9 10
    return 0;
}

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

int main() {
    string password;
    const string correct_pwd = "123456";
    
    do {
        cout << "请输入密码：" << endl;
        cin >> password;
    } while (password != correct_pwd); // 密码错误则重新输入
    
    cout << "密码正确，登录成功！" << endl;
    return 0;
}

适用场景需要保证循环体至少执行一次的场景（如密码验证、菜单选择、数据初始化校验）。

2.4continue和break语句

2.4.1continue语句

continue语句用于跳过本次循环剩余的所有语句，直接进入下一次循环的判断或初始化更新步骤，不会终止整个循环。

continue仅影响本次循环，整个循环的执行流程并未终止，后续循环仍可正常进行。

#include <iostream>
using namespace std;

int main() {
    // 遍历1到10，跳过偶数，仅打印奇数
    for (int i = 1; i <= 10; ++i) {
        if (i % 2 == 0) {
            continue; // 跳过本次循环剩余语句，直接进入下一次循环（i++）
        }
        cout << i << " "; // 输出：1 3 5 7 9
    }
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int i = 0;
    while (i < 10) {
        i++; // 此处更新循环变量，避免continue跳过导致死循环
        if (i % 3 == 0) {
            continue; // 跳过3的倍数，直接进入下一次条件判断（i < 10）
        }
        cout << i << " "; // 输出：1 2 4 5 7 8 10
    }
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入学生成绩（0-100，输入-1结束）：" << endl;
    
    while (true) {
        cin >> score;
        if (score == -1) {
            break; // 退出整个循环
        }
        if (score < 0 || score > 100) {
            cout << "输入非法，请重新输入！" << endl;
            continue; // 跳过后续语句，直接接收下一次输入
        }
        cout << "你输入的合法成绩是：" << score << endl;
    }
    return 0;
}

适用场景：

（1）满足特定条件时，无需执行本次循环的剩余逻辑，直接进入下一轮循环；

（2）筛选数据（跳过不符合条件的数据，仅处理合法数据）；

（3）避免无效的计算或输出，优化循环执行效率。

2.4.2break语句

break语句用于立即跳出当前所在的最内层循环（for/while/do-while),或跳出switch语句。在循环中，一旦执行break，会直接终止当前循环，不再执行循环体中剩余的语句，也不再进行后续的循环条件判断或更新操作。

#include <iostream>
using namespace std;

int main() {
    // 遍历1到10，遇到6立即跳出循环
    for (int i = 1; i <= 10; ++i) {
        if (i == 6) {
            break; // 触发跳出，后续循环不再执行
        }
        cout << i << " "; // 输出：1 2 3 4 5
    }
    cout << endl << "循环已终止";
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    // 外层循环：控制行数
    for (int row = 1; row <= 3; ++row) {
        // 内层循环：控制列数
        for (int col = 1; col <= 5; ++col) {
            if (col == 3) {
                break; // 仅跳出内层循环，外层循环继续下一轮
            }
            cout << col << " ";
        }
        cout << endl; // 换行
    }
    /* 输出结果：
    1 2 
    1 2 
    1 2 
    */
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int num = 0;
    // 无限循环（条件恒为true）
    while (true) {
        num++;
        if (num > 5) {
            break; // 满足条件时退出无限循环，避免死循环
        }
        cout << "当前数字：" << num << endl;
    }
    return 0;
}

适用场景：

（1）满足特定条件时，提前终止循环（无需执行完所有循环次数）;

（2）退出手动构建的无限循环(while(Ture));

（3）在switch语句中，终止某个case的执行，避免全透到下一个case。

三、数组、函数

3.1数组

数组是 C++ 中最基础的数据结构之一，用于存储一组相同数据类型的有序元素，具有固定长度、连续内存存储的特性。

（1）数组中的所有元素数据类型必须一致（如全是int、全是string，不能混合类型）

（2）数组的长度在声明时确定，且一旦确定无法修改

（3）数组元素在内存中连续存放，通过下标可以快速访问任意元素

（4）数组下标从0开始，最后一个元素的下标为数组长度-1

3.1.1一位数组

一维数组是最简单的数组形式，用于存储单行有序数据。

// 格式：数据类型 数组名[数组长度];

数据类型 数组名[常量表达式];

数据类型：指定数组元素的类型（int、double、char等）

数组名：符合c++标识符规范（字母、数字、下划线，不以数字开头）；

// 合法声明
int arr1[10]; // 声明一个能存储10个int类型元素的数组
const int LEN = 5;
double arr2[LEN]; // 用const常量指定长度，合法

// 不推荐（C++11后支持，兼容性差）
int n = 3;
char arr3[n]; // 用变量指定长度，不推荐使用

完全初始化

// 声明时直接用大括号初始化，元素用逗号分隔
int arr[5] = {1, 2, 3, 4, 5}; // 5个元素依次初始化

部分初始化

int arr[5] = {1, 2}; // 前2个元素初始化为1、2，剩余元素默认初始化为0
// 数组内容：[1, 2, 0, 0, 0]

省略数组长度

int arr[] = {1, 2, 3, 4}; // 省略长度，编译器自动推导长度为4
// 等价于 int arr[4] = {1, 2, 3, 4};

访问数组元素

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    
    // 访问单个元素
    cout << "第1个元素（下标0）：" << arr[0] << endl; // 输出：10
    cout << "第3个元素（下标2）：" << arr[2] << endl; // 输出：30
    cout << "最后一个元素（下标4）：" << arr[4] << endl; // 输出：50
    
    // 修改元素值
    arr[1] = 200;
    cout << "修改后第2个元素：" << arr[1] << endl; // 输出：200
    
    // 错误示例：越界访问（下标5，数组长度为5，最大下标4）
    // cout << arr[5] << endl; // 未定义行为，可能输出垃圾值或程序崩溃
    return 0;
}

一维数组的遍历：

（1）普通for循环（通过下标遍历，灵活可控）

#include <iostream>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    // 计算数组长度：sizeof(数组名) / sizeof(单个元素类型)
    int len = sizeof(arr) / sizeof(arr[0]);
    
    // 下标从0到len-1遍历
    for (int i = 0; i < len; ++i) {
        cout << arr[i] << " "; // 输出：1 2 3 4 5
    }
    return 0;
}

技巧：sizeof（arr)获取整个数组的字节大小,sizeof(arr[0])获取单个元素的字节大小，两者相除得到数组元素个数，避免硬编码数组长度。

(2)范围for循环

#include <iostream>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    
    // 范围for循环，自动遍历所有元素
    for (int num : arr) {
        cout << num << " "; // 输出：1 2 3 4 5
    }
    return 0;
}

3.1.2二维数组

二维数组可以理解为 **"数组的数组"**，常用于存储表格数据（行 + 列），如矩阵、成绩表等。

// 格式：数据类型 数组名[行数][列数];

数据类型 数组名[常量表达式1][常量表达式2];

行数：二维数组的行个数；

列数：二维数组中每一行的元素个数（列数不可省略）；

行数和列数均为常量表达式。

int matrix[3][4]; // 声明一个3行4列的二维int数组，共12个元素
const int ROW = 2;
const int COL = 3;
double scores[ROW][COL]; // 2行3列的二维double数组

初始化方式

（1）按行初始化

int matrix[3][4] = {
    {1, 2, 3, 4},   // 第0行
    {5, 6, 7, 8},   // 第1行
    {9, 10, 11, 12} // 第2行
};

（2）部分初始化

int matrix[3][4] = {
    {1, 2},   // 第0行：前2个元素为1、2，剩余为0
    {5}       // 第1行：第1个元素为5，剩余为0
    // 第2行：所有元素默认为0
};

（3）省略行数

int matrix[][] = {1,2,3,4,5,6}; // 错误：列数不可省略
int matrix[][4] = {{1,2}, {5,6}, {9,10}}; // 正确：推导行数为3

二维数组的访问

#include <iostream>
using namespace std;

int main() {
    int matrix[3][4] = {
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    
    // 访问单个元素：第1行（下标1）第2列（下标2）
    cout << "matrix[1][2] = " << matrix[1][2] << endl; // 输出：7
    
    // 修改元素值
    matrix[2][3] = 120;
    cout << "修改后matrix[2][3] = " << matrix[2][3] << endl; // 输出：120
    return 0;
}

二维数组的遍历

#include <iostream>
using namespace std;

int main() {
    int matrix[3][4] = {
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    
    // 计算行数和列数
    int rows = sizeof(matrix) / sizeof(matrix[0]); // 行数：3
    int cols = sizeof(matrix[0]) / sizeof(matrix[0][0]); // 列数：4
    
    // 嵌套循环遍历
    for (int i = 0; i < rows; ++i) { // 外层：遍历行
        for (int j = 0; j < cols; ++j) { // 内层：遍历列
            cout << matrix[i][j] << " ";
        }
        cout << endl; // 每行遍历完换行
    }
    /* 输出结果：
    1 2 3 4 
    5 6 7 8 
    9 10 11 12 
    */
    return 0;
}

3.1.3字符数组

用来存放字符数据的数组是字符数组，字符数组中的一个元素存放一个字符。

定义：char c[10]={'I',' ','a','m',' ','h','a','p','p','y'}

赋值：只能对字符数组的元素赋值，而不能用赋值语句对整个数组赋值。

char c[5];

c={'A','B'}; //错误，不能对整个数组一次赋值

c[0]='A',c[1]='B'//对数组元素赋值，正确

3.2函数

函数是 C++ 程序的基本组成单元，用于封装一段完成特定功能的可复用代码，能提高程序的可读性、模块化程度和代码复用率。

3.1函数定义

函数定义是函数的完整实现，包含函数头和函数体两部分

// 语法格式

返回值类型 函数名(参数列表) {

函数体; // 实现函数功能的代码块

return 返回值; // 与返回值类型匹配，void类型无需此语句

}

返回值类型：指定函数执行完成后返回的数据类型（如int、diuble、char、void等）；void表示函数无返回值，无需写return语句（或可写return；，无实际返回数据）。

函数名：符合C++标识规范（字母、数字、下划线、不以数字开头）

函数体：用大括号{}包裹的代码块，实现函数的具体功能。

return语句：将返回值传递给函数调用者，其数据类型必须与"返回值类型一致"，void类型函数可省略return语句

// 定义一个int类型返回值、接收两个int参数的求和函数
int add(int a, int b) {
    int result = a + b; // 函数体：实现求和逻辑
    return result; // 返回求和结果，与返回值类型int匹配
}

// 定义一个void类型（无返回值）、无参数的打印函数
void printWelcome() {
    cout << "欢迎使用C++函数！" << endl; // 函数体：实现打印功能
    // void类型无需return语句，可省略
}

3.2函数声明

函数声明是告诉编译器函数的存在，仅提供函数的基本信息（返回值类型、函数名、参数列表），不包含函数体。

// 语法格式（与函数定义的函数头一致，末尾加分号）

返回值类型 函数名(参数列表);

解决函数调用在前、定义在后的问题（编译器从上到下编译，未声明直接调用后续定义的函数会报错）；

通常放在程序开头（或头文件.h中），函数定义可放在程序末尾或其他源文件.cpp中；

声明时的参数名可省略，仅保留数据类型即可（但为了可读性，推荐保留参数名）。

#include <iostream>
using namespace std;

// 函数声明（解决调用在前、定义在后的问题）
int add(int a, int b); // 完整声明（保留参数名）
void printWelcome();   // 无参数函数声明
double calculateArea(double r); // 省略参数名也可：double calculateArea(double);

int main() {
    // 函数调用（此时编译器已通过声明知道函数存在）
    printWelcome();
    
    int x = 10, y = 20;
    int sum = add(x, y); // 接收函数返回值
    cout << x << " + " << y << " = " << sum << endl;
    
    double radius = 3.0;
    double area = calculateArea(radius);
    cout << "圆的面积：" << area << endl;
    
    return 0;
}

// 函数定义（放在main()之后，需提前声明）
int add(int a, int b) {
    return a + b;
}

void printWelcome() {
    cout << "欢迎使用C++函数！" << endl;
}

double calculateArea(double r) {
    const double PI = 3.14159;
    return PI * r * r;
}

3.3函数调用

函数调用是执行函数功能的方式，通过函数名 + 实际参数触发函数执行。

// 语法格式（无参数时省略括号内的内容）

函数名(实际参数列表);

函数调用的3种形式

#include <iostream>
using namespace std;

// 定义求和函数
int add(int a, int b) {
    return a + b;
}

int main() {
    int a = 10, b = 20;
    
    // 形式1：将返回值赋值给变量
    int sum = add(a, b);
    cout << "求和结果：" << sum << endl;
    
    // 形式2：直接输出返回值
    cout << "直接输出求和结果：" << add(a, b) << endl;
    
    // 形式3：作为表达式的一部分参与运算
    int total = add(a, b) + 50;
    cout << "求和结果+50：" << total << endl;
    
    // void类型函数调用（仅执行功能，无返回值）
    printWelcome();
    
    return 0;
}

void printWelcome() {
    cout << "函数调用示例！" << endl;
}

3.4函数默认参数

C++允许为函数的形参指定默认值，调用函数时，若未传递该参数的实参，编译器会自动使用默认值；若传递了实参，则使用实参的值。

语法规则：

默认参数必须在函数声明或定义中指定（通常在声明中指定，定义中不再重复）；

默认参数的指定必须从右往左依次进行，不能跳过中间参数指定默认值；

同一参数不能多次指定默认值（声明和定义中只能出现一次）。

#include <iostream>
using namespace std;

// 函数声明：指定b的默认值为10，c的默认值为20（从右往左指定）
int add(int a, int b = 10, int c = 20);

int main() {
    cout << add(5) << endl; // 仅传递a，b=10、c=20，结果：35
    cout << add(5, 15) << endl; // 传递a、b，c=20，结果：40
    cout << add(5, 15, 25) << endl; // 传递所有参数，结果：45
    return 0;
}

// 函数定义：无需重复指定默认值
int add(int a, int b, int c) {
    return a + b + c;
}

3.5内联函数

内联函数是 C++ 中一种用于优化程序执行效率的特殊函数，核心是通过 "空间换时间" 的策略，减少函数调用带来的开销。

普通函数调用时，程序会跳转到函数的内存地址执行函数体，执行完毕后再跳转回调用点；而内联函数会在编译阶段被编译器展开，直接将函数体的代码嵌入到每个调用该函数的位置，无需进行跳转和栈帧操作；

本质是 "空间换时间"：函数被多次调用时，会生成多份函数体拷贝（增加可执行文件体积 / 内存占用），但节省了每次调用的栈开销（提升程序执行速度）

声明与定义

内联函数推荐将声明和定义合并在一起（通常放在头文件中）

// 语法：inline 关键字放在返回值类型前

inline 返回值类型 函数名(参数列表) {

函数体; // 实现函数功能的代码块

return 返回值; // void类型无需此语句

}

#include <iostream>
using namespace std;

// 定义一个内联函数：求两个整数的最大值
inline int max(int a, int b) {
    // 函数体逻辑需简单，避免复杂流程
    return a > b ? a : b; // 三目运算符，返回较大值
}

int main() {
    // 调用内联函数
    int x = 10, y = 20;
    int result1 = max(x, y);
    cout << x << " 和 " << y << " 的最大值：" << result1 << endl; // 输出：20
    
    int m = 30, n = 15;
    int result2 = max(m, n);
    cout << m << " 和 " << n << " 的最大值：" << result2 << endl; // 输出：30
    
    return 0;
}