1.嵌套调用和链式访问
1.1嵌套调用
概念: 在调用一个函数的过程中,可以调用另一个函数。
例子:
计算某年某月有多少天?
思路:
• is_leap_year( ) :根据年份确定是否是闰年。
• get_days_of_month( ):调用 is_leap_year 确定是否是闰年后,再根据月计算这个月的天数。
#include<stdio.h>
int is_leap_year(int y)
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))//判断闰年的方法
{
return 1;//是闰年就返回 1
}
else
{
return 0;//不是就返回 0
}
}
int get_days_of_month(int y, int m)
{
int days[] = { 0,31,28,31,30,31,30,31,30,31,30,31 };//写多个 0 为了让数字与月份对齐
int day = days[m];
if (is_leap_year(y) && m == 2)//在 get_days_of_month() 中调用了 is_leap_year()
{
day = day + 1;
printf("是闰年 ");
}
return day;
}
int main()
{
int y = 0;
int m = 0;
scanf("%d %d", &y, &m);
int ret = get_days_of_month(y, m);
printf("%d\n", ret);
return 0;
}
这一段代码,完成了一个独立的功能。代码中反应了不少的函数调用:
- main 函数调用 scanf、printf、get_days_of_month
- get_days_of_month 调用 is_leap_year
记住:
函数之间可以嵌套调用,但函数不能嵌套定义。
1.2链式访问
链式访问就是将一个函数的返回值作为另外一个函数的参数,像链条一样将函数串起来就是函数的链式访问。
例如:
#include<stdio.h>
#include<string.h>
int main()
{
int s = strlen("abcdef");//strlen() 的头文件是 string.h,求一个字符串的长度
printf("%d\n", s);//打印长度
return 0;
}
前面的代码完成动作写了 2 条语句,把如果把 strlen 的返回值直接作为 printf函数的参数呢?这样就是一个链式访问的例子了。
#include<stdio.h>
#include<string.h>
int main()
{
printf("%d\n", strlen("abcdef"));//链式访问
return 0;
}
再看一个有趣的代码:
#include<stdio.h>
int main()
{
printf("%d",printf("%d",printf("%d",43)));
return 0;
}
这个代码的关键是明白 printf 函数的返回值是什么?
int printf ( const char * format, ... );
printf 函数返回的是打印在屏幕上的字符的个数。
解释:
第一的 printf 打印的是第二个 printf 的返回值,第二个 printf 打印的是第三个 printf 的返回值。
- 第三个 printf 打印43,在屏幕打印2个字符,再返回2。
- 第二个 printf 打印2,在屏幕打印1个字符,再返回1。
- 第一个 printf 打印1。
4.所以屏幕上最终打印:4321 。
2.传值调用和传址调用
C语言中函数调用可大致分为传值调用和传址调用。
2.1传值调用
- 传值调用: 函数调用时,把实参的值传递给对应的形参变量。
- 在实参传递给形参的时候,形参相当于实参的一份临时拷贝。
- 函数体内对形参操作,形参变量的变化不会影响到实参的值。即函数调用过程中,数据的传递是单向的。
例子:
#include<stdio.h>
void Swap(int x, int y)
{
int z = x;
x = y;
y = z;
}
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//打印
printf("交换前:a=%d b=%d\n", a, b);
//交换
Swap(a, b);
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
结果:
Swap( ) 函数的功能是交换两个参数的值。但运行结果表示,它只交换了两个形参变量 x 和 y ,没有交换 main( ) 中的实参 a 和 b 的值。
2.2传址调用
- 传址调用时,实参为地址(一维数组名被看成数组首元素的地址)
- 一个函数对数组进行操作时,通常用一个整型变量来表示可操作的数组元素个数。
- 形参一般为:数组类型或指针类型。
把上面的代码换成传址调用的方式再写一下:
#include<stdio.h>
void Swap(int* px, int* py)
{
int z = *px;//z = a
*px = *py; //a = b
*py = z; //b = z
}
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//打印
printf("交换前:a=%d b=%d\n", a, b);
//交换
Swap(&a,&b);// & 是取地址的运算符
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
结果:
Swap( ) 函数实现了参数的交换。解释:
1.& 运算符,被称为 “取地址运算符”。&a、&b 的值为变量 a 的地址,变量 b 的地址。
2. * 运算符,被称为 “指针运算符”。功能是:取某 “指针变量” 所指向的变量中的内容。
3.所以思路是:px 和 &a 是一样的,地址相同。py 和 &b 是一样的,地址相同。
所以,px 通过 *(指针运算符)来找到 a 的值,也就是通过 a 的地址找到 a 的值。可以简化为:*px = a。
反之,py 也是如此。
3.函数的声明和定义
3.1单个文件
一般我们在使用函数的时候,直接将函数写出来就使用了。
例子:
写一个函数判断一年是否是闰年。
#include<stdio.h>
//判断一年是否是闰年
int is_leap_year(int y)//一整段都是函数的定义
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
{
return 1;
}
else
{
return 0;
}
}
int main()
{
int y = 0;
scanf("%d", &y);
int ret = is_leap_year(y);//函数的调用
if (ret == 1)
{
printf("是闰年\n");
}
else
{
printf("不是闰年\n");
}
return 0;
}
上面代码的第 4~14 行是函数的定义,第 21 行是函数的调用。
这种场景是函数的定义在函数调用之前,没有什么问题。
如果把函数的定义在函数调用之后,如下:
#include<stdio.h>
int main()
{
int y = 0;
scanf("%d", &y);
int ret = is_leap_year(y);
if (ret == 1)
{
printf("是闰年\n");
}
else
{
printf("不是闰年\n");
}
return 0;
}
//判断一年是否是闰年
int is_leap_year(int y)
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
{
return 1;
}
else
{
return 0;
}
}
- 这是因为C语言编译器对源代码进行编译时,从第一行往下扫描的,当遇到第 8 行的 is_leap_year 函数调用时,并没有发现前面有 is_leap_year 的定义,就出现上面的警报。
- 解决办法:在函数调用之前先声明 一下is_leap_year 这个函数,声明只要交代清楚:函数名,函数的返回类型和函数的参数。
- 如:int is_leap_year (int y); 这就是函数的声明。函数声明中参数只保留类型,省略掉名字也是可以的。
代码变成这样就能正常编译了:
#include<stdio.h>
int is_leap_year(int y);//函数的声明
int main()
{
int y = 0;
scanf("%d", &y);
int ret = is_leap_year(y);
if (ret == 1)
{
printf("是闰年\n");
}
else
{
printf("不是闰年\n");
}
return 0;
}
//判断一年是否是闰年
int is_leap_year(int y)//函数的定义(这一段代码叫函数的定义)
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
{
return 1;
}
else
{
return 0;
}
}
- 函数的调用一定要满足,先声明后使用。
- 函数的定义也是一种特殊的声明,所以函数定义放在调用之前也是可以的。
3.2多个文件
在代码量比较大时,不会将所有的代码都放在一个文件中;会根据程序的功能,将代码拆分放在多个文件中。
一般情况下:
- 函数的声明、类型的声明放在头文件(.h)中。
- 函数的实现是放在源文件(.c)中。
例子:写一个实现加法的函数。
add.h
//函数的声明
int Add(int a, int b);
add.c
//函数的定义
int Add(int a, int b)
{
return a + b;
}
test.c
#include<stdio.h>
#include"add.h"
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//函数的调用
int ret = Add(a, b);
printf("%d\n", ret);
return 0;
}
运行结果:
4.static 和 extern
static 和 extern 都是C语言中的关键字。
static 是静态的的意思,可以用来:
- 修饰局部变量
- 修饰局部变量
- 修饰函数
extern 是用来声明外部符号的。
插一个知识点:
- 作用域(scope) 是程序设计概念,一般来讲,一段程序代码中所用到的名字并不总是有效的(可用的),而限定这个名字的可用性的代码范围就是这个名字的作用域。
- 局部变量的作用域是变量所在的局部范围。
- 全局变量的作用域是整个工程(项目)。
- 生命周期 指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的一个时间段。
- 局部变量的生命周期是:进入作用域变量创建,生命周期开始,出作用域生命周期结束。
- 全局变量的生命周期是:整个程序的生命周期。
4.1 static 修饰局部变量
代码 1:
#include<stdio.h>
void test()
{
int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}
结果:
代码 2:
#include<stdio.h>
void test()
{
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}
结果:
对比代码1和代码2的效果,理解 static 修饰局部变量的意义。
- 代码1 的 test( ) 函数中的局部变量 i 是每次进入 test( ) 函数先创建变量(生命周期开始)并赋值为0,然后 ++,再打印,出函数的时候变量生命周期将要结束(释放内存)。
- 代码2 中,我们从输出结果来看,i 的值有累加的效果,其实 test( ) 函数中的 i 创建好后,出函数的时候是不会销毁的,重新进入函数也就不会重新创建变量,直接上次累积的数值继续计算。
- 结论:static 修饰局部变量改变了变量的生命周期,生命周期改变的本质是改变了变量的存储类型,本来一个局部变量是存储在内存的栈区的,但是被 static 修饰后存储到了静态区。存储在静态区的变量和全局变量是一样的,生命周期就和程序的生命周期一样了,只有程序结束,变量才销毁,内存才回收。但是作用域不变的。
- 使用建议:未来一个变量出了函数后,我们还想保留值,等下次进入函数继续使用,就可以使用 static 修饰。
作图理解:
4.2static 修饰全局变量
代码 1:
add.c
int g_val = 2024;
test.c
#include<stdio.h>
extern int g_val;//extern 声明外部符号
int main()
{
printf("%d\n", g_val);
return 0;
}
代码 2:
add.c
static int g_val = 2024;//static 修饰全局变量
test.c
#include<stdio.h>
extern int g_val;//extern 声明外部符号
int main()
{
printf("%d\n", g_val);
return 0;
}
- extern 是用来声明外部符号的,如果一个全局的符号在 A 文件中定义的,在 B 文件中想使用,就可以使用extern 进行声明,然后使用。代码 1 正常,代码 2 在编译的时候会出现链接性错误。
- 结论:
一个全局变量被 static 修饰,使得这个全局变量只能在本源文件内使用,不能在其他源文件内使用。
本质原因 是全局变量默认是具有外部链接属性的,在外部的文件中想使用,只要适当的声明就可以使用。
但是 全局变量被 static 修饰之后,外部链接属性就变成了内部链接属性,只能在自己所在的源文件内部使用了,其他源文件,即使声明了,也是无法正确使用。- 使用建议: 如果一个全局变量,只想在所在的源文件内部使用,不想被其他文件发现,就可以使用 static 修饰。
4.3static 修饰函数
代码 1:
add.c
int Add(int x, int y)
{
return x + y;
}
test.c
#include<stdio.h>
extern int Add(int x, int y);
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int ret = Add(a, b);
printf("%d\n", ret);
return 0;
}
代码 2:
add.c
static int Add(int x, int y)//static 修饰函数
{
return x + y;
}
test.c
#include<stdio.h>
extern int Add(int x, int y);
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int ret = Add(a, b);
printf("%d\n", ret);
return 0;
}
代码 1 是能够正常运行的,但是代码 2 就出现了链接错误。
- static 修饰函数和 static 修饰全局变量是一模一样的,一个函数在整个工程都可以使用,被static修饰后,只能在本文件内部使用,其他文件无法正常的链接使用了。
- 本质是因为函数默认是具有外部链接属性,具有外部链接属性,使得函数在整个工程中只要适当的声明就可以被使用。但是被 static 修饰后变成了内部链接属性,使得函数只能在自己所在源文件内部使用。
- 使⽤建议: 一个函数只想在所在的源文件内部使用,不想被其他源文件使用,就可以使用 static 修饰。