C++ 函数与编译预处理

本系列为 C++ 的入门学习者服务，旨在于为此前无 C++ 基础的学习者简单介绍关于 C++ 语言基础的部分知识，如果已入门 C++，则不需要阅读本系列。

3.1 C++ 函数的定义

• 任何 c++ 程序由至少一个函数组成，其中 main 函数是必不可少的。
• 函数除了是程序的基本组成部分之外，更重要的是可以完成特定的功能。
• 为了完成特定的功能，函数需要数据的输入（参数），并给出数据的结果（返回值）。
• 通过编写和调用函数可以简化程序逻辑，提高编码效率，也是团队合作必备的基础。

1. 系统函数与自定义函数

• 系统函数：不需要我们编写，由系统提供的函数，也称为库函数。如：sqrt()。
• 自定义函数：自己编写的函数。

使用系统函数可以提高编程效率，但并不能覆盖所有的需求。因此我们需要学习自己编写函数，也就是自定义函数。编写自定义函数是结构化程序设计的主要步骤。

2. 函数参数和返回值

• 参数：向被调函数输入的、被调函数运行时所需要的数据。

  参数的注意事项

• 返回值：将函数运行的结果输出，返回给调用函数。

  返回值的注意事项

例：

sqrt() 开平方根函数

使用该函数的时候，需要一个输入的值，并得到对应的输出。如：y=sqrt(x)

对于 sqrt 函数，需要一个类型为你 double 的参数（输入），并提供一个类型为 double 的返回值（输出）。

3. 自定义函数的步骤

① 分析函数的参数（个数，类型）

② 分析函数的返回值（类型）

③ 实现从参数得到返回值的过程

例：编写一个自定义函数 max。

函数功能：求两个整数当中较大的数。

函数逻辑：使用判断语句即可。

参数分析：需要两个参数，都是整数类型。

返回值分析：结果返回一个整数。

4. 自定义函数的语法格式

1返回值类型 函数名 ( 函数参数列表 ) //函数头2{3    //函数体4    return 返回值;5}

• 函数参数：数量为任意个，如果为 0 可以省略。
• 返回值：数量只能为 0 个或 1 个，用关键词 return 实现，且代码运行时遇 return 自动结束该函数。如果没有返回值，函数名前的返回值类型用 void 表示。

例 1：有参有返函数：编写一个自定义函数 max 求两数的较大数。

1int max(int a, int b) //每一个参数独立，即不能写成int a, b2{3	int c = a > b ? a : b;4	return c; //通过该语句返回结果5}

例 2：无参无返函数：打印函数 print。

1void print (void) //参数的void可省略2{3	cout << "*********" << endl;4	cout << "*example*" << endl;5	cout << "*********" << endl;6} //本函数仅仅实现打印的功能，无数据处理

例 3：有参有返函数：求最大公约数的函数 gcd。

• 函数功能：求两个整数的最大公约数。
• 函数逻辑：使用递推法（欧几里得算法）或穷举法皆可。
• 参数分析：需要两个参数，都是整数类型。
• 返回值分析：结果返回一个整数。

穷举法：

1int gcd(int a, int b) //与上例相同2{3	int c = a < b ? a : b; //二者中较小的数4	while (a % c != 0 || b % c != 0) //尝试5		--c;6	return c; //得到结果7}

递推法（欧几里得算法或辗转相除法）：

1int gcd(int a, int b) //注意分析返回和参数类型2{3	int c = a % b; //c是a除以b的余数4    while(c != 0) //欧几里得算法递推求解5    {6        a = b;7        b = c;8        c = a % b;9    }10	return b; //返回最后的结果11}

5. 函数定义小结

1. 分析清楚函数所需的参数和能提供的返回值至关重要。
2. 在函数实现过程中需要的辅助变量，不能作为参数来使用，只能定义在函数的内部。
3. 遇到 return 语句之后函数自动结束，因此一般将 return 语句放在函数的最后。

3.2 函数的调用和声明

1. 函数的调用过程

1. 主调函数将参数（实际参数）传递给自定义函数，并暂停主调函数的运行。
2. 自定义函数根据得到的参数（形式参数）值进行计算，并得出返回值结果。
3. 自定义函数将返回值回传给主调函数，结束自定义函数并继续主调函数的运行。

2. 函数的三种调用情况

• 系统函数：

  • 包含所在的头文件
  C++

  1#include <cmath>2int main()3{4    sqrt(3);5}

• 自定义函数：

  • 先定义，再调用，可以直接调用
  C++

  1int max(int a, int b)2{3	int c = a > b ? a : b;4	return c;5}6int main()7{8    max(3, 4);9}

  • 先调用，再定义，则需补充声明
  C++

  1int max(int a, int b);//声明函数（见下一小节）2int main()3{4    max(3,4);5}6int max(int a, int b)7{8	int c = a > b ? a : b;9	return c;10}

3. 函数的声明

从结构化程序设计的角度，通常是先调用后定义。

而先调用后定义要先声明函数避免系统由上到下执行语句时函数名未定义。

函数声明是将函数头添加分号而构成的语句，参数名可以省略。

例：

• int max(int a, int b);
• void print(void);
• int gcd(int, int); //省略参数名

4. 函数的参数传递

(1) 两种参数

注：实参和形参个数和排列顺序一一对应，并且对应的参数应类型匹配（赋值兼容）。

(2) 传递过程

先计算实参表达式的值，再将该值传递（拷贝）给对应的形参变量。

注：实参与形参的单向传递（拷贝的解释）

形参具备自己的存储空间，和实参的关系是单向传递关系。对形参的赋值不会影响对应的实参！

例 1：单向传递的示例

1void f(int a) //a为形参2{3    ++a;4    cout << a << ' '; //输出行15}6int main()7{8    int x = 100; //x为实参9    f(x);10    cout << x << endl; //输出行211}12// 输出结果为101 100 即x的值不变

例 2：反例——数据交换的失败

1void myswap(int x, int y)2{3    cout << "myswap:" << x << ' ' << y << endl;4    int t = x;5    x = y;6    y = t;7    cout << "myswap:" << x << ' ' << y << endl;8}9int main()10{11    int a, b;12    cin >> a >> b;13    cout << "main: " << a << ' ' << b << endl;14    myswap(a, b);//传值15    cout << "main: " << a << ' ' << b << endl;16}17// 运行中形参可以成功交换，但实参不会交换

可以将形参添加引用如：void myswap(int &x, int &y) 可以成功交换。

5. 函数返回值

1return 表达式;

作用：返回函数的结果。

操作本质：（拷贝）将 return 后面表达式的值传给指定类型的临时变量输出，不可寻址。

如：临时变量不能做左值，max(a, b) = 2 是非法的。

返回值的类型：

• 如果该函数返回类型不为 void，那么函数的调用可以组成函数调用表达式参与运算。

  • 例：cout << max(a, b);

• 如果该函数返回类型为 void，那么函数的调用只能加上分号成为函数语句。

  • 例：print();

• 如果 return 后面表达式的类型和函数定义的返回类型不一致，以函数定义类型为准进行转换。

  • 例：返回值类型转换

    C++

    1int f()2{3    return 2.5;4}5// 返回的临时变量将为2

3.3 变量作用域和生存期

• 变量除了具备类型、名字和值之外，还有空间和时间上的特性，也被称为变量的作用域和生存期。
• 根据作用域和生存期的不同，可对变量进行不同形式的分类。

1. C++ 的内存分布

2. 变量的作用域

根据作用域不同，将变量分为全局变量和局部变量。

(1) 全局变量

• 如果一个变量定义的位置不在任何函数或复合语句内，则该变量成为全局变量可以被所有函数或层次访问。
• 全局变量的作用域：由定义处开始，到所在文件尾部结束，因此也称为文件作用域。
• 一般情况下，将全局文件定义在文件的开头部分，则所有函数中都可以对全局变量进行读写。

例：全局变量的使用

1int n=100; //n为全局变量2void func()3{ 4    n *= 2;5}6int main()7{8    n *= 2; cout<<n<<endl; //输出2009    func(); cout<<n<<endl; //输出40010	return 0;11}

注：

• 全局变量的使用应尽量谨慎，过多地使用因为每一个函数都可以更改全局变量，容易导致逻辑和流程的混乱。
• 全局变量的存储地点在内存的全局数据区，如不赋初始值则自动初始化为 0。

(2) 局部变量

• 如果一个变量定义在某个特定的函数或复合语句内，则该变量为局部变量，只能在该函数或层次内被访问。
• 局部变量的作用域：从变量定义开始，到所在的函数或复合语句的尾部结束，也称为块域。
• 局部变量的存储地点在内存的栈区，如果不初始化就为随机值。

(3) 作用域的覆盖

• 变量重名在作用域覆盖的区域内遵循局部优先的规则。
• 如果局部变量覆盖了全局变量，可以使用域作用符::调用同名全局变量。

1int n=100; //全局变量n2int main()3{4	int i=200, j=300;5	cout << n << '\t' << i << '\t' << j << endl;6	{7		int i=500, j=600, n; //局部变量n，层次内的变量i, j8	    n=i+j;9		cout<< n << '\t' << i << '\t' << j << endl;10		cout<< ::n <<endl; //输出全局变量n11	}12	n=i+j; //修改全局变量13	cout << n << '\t' << i << '\t' << j << endl;14	return 0;15}

(4) 局部声明作用域

作用范围仅限声明语句内，因此可省略其参数名。

1int max(int a, int b);2int max(int, int);

3. 变量的生存期

• 根据生存期不同，将变量分为动态变量和静态变量。
• 不同生存期的变量，用存储类型的不同来体现。

(1) 动态变量

当程序运行至变量所在的函数的时候，系统对其进行空间分配；当所在的函数运行结束时，系统收回其存储空间。之前使用的局部变量一般就属于动态变量。

(2) 静态变量

静态变量：当程序开始运行的时候，变量即被创建，并一直生存至程序的结束。之前的全局变量即为静态变量。另可改造普通局部变量的属性，使其成为静态局部变量。

(3) 存储类型

变量定义的完整方式：存储类型 数据类型 变量名 = 初始值

C++ 中支持的 4 种不同的存储类型：

① auto

• 普通的局部变量都属于 auto 类型，也称为自动变量，属于默认类别，可以省略。
• 最新版本的 C++ 中对 auto 的定义已经有所变化。

例：int c 和 auto int c 是等价的。（在 C++98 环境中）

② register

• 用 register 修饰的变量称为寄存器变量，使用方式与 auto 变量几乎一致，但存储在 CPU 的寄存器中，不可寻址，不推荐使用。
• register 在 C++17 及之后被弃用。

③ static

用 static 修饰的变量具备静态属性，根据所修饰变量的作用域不同可以分为静态局部变量和静态全局变量。

A. 静态局部变量

如果在局部变量上使用 static 修饰，则成为静态局部变量，其作用域不变依旧为局部，当其所在的块第一次被执行时，系统在全局数据区开辟其空间，直到整个程序结束才释放，即：静态局部变量具有局部作用域，但却具有全局生命期。

例：

1int st()2{3    static int t = 100; //仅执行一次，下一次接着上一次的值运算4	t ++;5    return t;6}7int at()8{9    int t = 100; //自动变量，每运行一次销毁一次，下一次又重新生成10	t ++;11    return t;12}13int main()14{15    int i;16	for(i=0; i<5; i++)17        cout << at() << '\t'; //输出5个10118    cout << endl;19	for(i=0; i<5; i++)20        cout << st() << '\t'; //输出101~105的序列21    cout << endl;22	return 0;23}

B. 静态全局变量

• 全局变量本已经具备静态属性：存放在全局数据区内，生存期限为整个程序，并默认初始化为 0 等。
• 用 static 修饰全局变量，其作用是将该变量的作用域限定在文件内，不能为其他文件调用。

④ extern

敬请期待

3.4 函数的嵌套和递归

在 C++ 中所有的函数地位是平等的，也就是说不允许嵌套定义，即将函数 A 定义在函数 B 当中。

嵌套调用是允许的，也就是在函数 A 中调用在函数 B。

main 函数的特权：是程序运行的起点和终点。

1. 函数的递归

• 如果在定义函数 A 中的过程中调用函数 A，则称为直接递归调用。
• 如果在定义函数 A 中调用函数 B，在定义函数 B 中调用函数 A，则称为间接递归。

2. 递归函数注意事项

• 递归函数的执行分为递推和回归两个过程。这两个过程由递归终止条件控制，即逐 层递推，直至递归终止条件，然后逐层回归。
• 编写递归函数的大致模式：首先判断递归终止条件，如果不终止则展开递归条件。
• 递归函数容易编写且可读性高，但运行效率极低，应避免随意使用。

3. 递归函数算法示例

(1) 阶乘求解

1int fac(int n)2{3	if(n == 0 || n == 1) //递归终止条件4		return 1;5	else6		return n * fac(n - 1); //递归进行条件7}

运行分析：以 fac(5) 为例：

① n=5，返回的结果为 5*fac(4)。在 fac(4) 得出结果前，函数无法结束，程序转入执行 fac(4)。

② n=4，返回的结果为 4*fac(3)。在 fac(3) 得出结果前，函数无法结束，程序转入执行 fac(3)。

……

⑤ n=1，此时得出结果为 1，至此分解部分结束，递归终止。

⑥ 在确认 fac(1) 的值之后，fac(2) 的结果也可以确定为 2*1=2。

⑦ 在确认 fac(2) 的值之后，fac(3) 的结果也可以 确定为 3*2=6。

……

⑨ 在确认 fac(4) 的值之后，fac(5) 的结果最终确定为 5*24=120，此时综合部分结束，运行完毕。