C语言.（二）函数的基本语法

最新推荐文章于 2024-08-19 16:02:04 发布

Joseit

最新推荐文章于 2024-08-19 16:02:04 发布

阅读量843

点赞数 8

文章标签： c语言

本文链接：https://blog.csdn.net/Joseit/article/details/136033037

版权

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 修饰。

Joseit

关注

8
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
C语言.（二）函数的基本语法

一般我们在使用函数的时候，直接将函数写出来就使用了。例子：写一个函数判断一年是否是闰年。//判断一年是否是闰年int is_leap_year(int y)//一整段都是函数的定义return 1;//函数的调用printf("是闰年\n");elseprintf("不是闰年\n");return 0;上面代码的第 4~14 行是函数的定义第 21 行是函数的调用。
复制链接

扫一扫