C语言 函数

Posted on In Views: Word count in article: 2.8k Reading time ≈ 28 mins.

一、函数

1.1 什么是函数

函数：完成特定功能的程序段
维基百科对函数的定义：子程序
  1.在计算机科学中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具有相对独立性。
  2.一般会有输入参数并有返回值，提供了对实现过程的封装和细节的隐藏。

1.2 C语言中函数分类

函数主要分为两大类：库函数和自定义函数

库函数：编译器提供的可在C源程序中调用的函数。库函数又分为两类，一类是C语言标准规定的库函数，一类是编译器特定的库函数（如：MSVC编译器提供的scanf_s函数）。由于版权原因，库函数的源代码一般不可见，但在头文件中可以看到它对外提供的接口)

使用库函数需要引用对应头文件： #include  <文件名>
库函数参考手册网址：

http://www.cplusplus.com/

自定义函数：程序员根据需要编写的函数，也是本文谈论的重点

二、函数定义与声明

2.1函数的定义

函数的定义：一个函数的具体实现
语法：
返回类型 函数名(形参列表){
  功能代码；
}

返回类型：一个函数执行完后可以返回特定的值给主程序，返回类型就是指定返回值的数据类型，如果不需要返回值，此时写上void。如果有返回值，在功能代码部分必要要有return语句;

函数名：一个标识符，应该尽量使用能表明函数功能的名字，比如一个求和的函数可以使用sum命名

形参列表：什么是形参后面会讲到，这里先理解成参数列表。指需要传入到函数内的参数，当不要参数时为空，需要参数时要写上参数类型和参数名

功能代码：大括号内是函数的功能代码，是函数功能具体的实现代码

return: 终止当前函数执行，并返回return后面的值（类型必须与返回类型相同）。如果函数中没有return语句，那么只有遇到函数反大括号才会结束函数的执行

1
2
3
4
5
6
7
//定义了一个求两值相加和的函数，函数返回类型是int，所以只能求整数相加。
//函数名为sum,函数需要两个形式参数，分别是x、y且都为int类型
//函数最后返回 x+y的值

int sum(int x, int y) { 
	return x + y;
}
1
2
3
4
5
//定义了一个打印函数，函数没有返回值，不需要传入参数，函数名为print
//执行此函数输出欢迎访问我的博客，由于没有返回值，所以不需要使用return语句
void print() {
	printf("欢迎访问我的博客\n");
}

2.1函数的声明

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
	int result = 0;
	int a = 10;
	int b = 20;
	result = sum(a, b);名叫sum的函数  //编译是从上到下的顺序，编译时此处会报错或警告，因为此时找不到一个名为sum的函数
	return 0;
}

int sum(int x, int y) {
	return x + y;
}

函数声明：
1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么，但是具体是不是存在，函数声明决定不了
2.函数的声明一般在函数使用之前出现，要满足先声明后使用
3.函数声明一般要放在头文件内
4.函数定义出现在函数调用（使用）之前，可以省略函数声明

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

int sum(int x, int y) { //函数定义在使用之前，这种情况可以不进行函数声明
	return x + y;
}

int main() {
	int result = 0;
	int a = 10;
	int b = 20;
	result = sum(a, b);
	return 0;
}

函数声明语法： 返回类型 函数名(参数列表);

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int sum(int x, int y); //函数声明
int main() {
	int result = 0;
	int a = 10;
	int b = 20;
	result = sum(a, b);
	return 0;
}

int sum(int x, int y) {
	return x + y;
}

三、写函数小技巧

写函数时候，首先要了解需求，即这个函数是干什么的、要解决什么问题。是否需要返回值，如果需要返回值类型是怎样的。是否需要传入参数。要做到高内聚低耦合。

3.1判断质数的函数

分析：质数就是只能被1和本身整除的数字。如果被其他数字整除就不是质数。假设一个数n，那在
[2，n-1]的范围内用n对它们取余数都必须不等于0。但是我们可以继续优化，减少计算。我们对n开平方根。那么范围可以是[2，√n]。另外如果是1或2那么本身就是质数所以不需要计算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <math.h>
int prime_number(int n) { //1 代表是质数  0 代表 不是质数
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		int i = 2;
		for (i = 2; i <= sqrt(n); i++) // sqrt是开平方根的库函数，需要引用头文件math.h
		{
			if (n % i == 0) //如果在[2,√n]范围内的某个数被n取余数是0，就不是质数，终止函数的后续判断
				return 0;
		}
	}
	return 1;
}
int main(void) {
	int n = 0;
	printf("请输入一个数：》");
	scanf("%d", &n);
	if (prime_number(n))
	{
		printf("%d是质数\n", n);
	}
	else
	{
		printf("%d不是质数\n", n);
	}
}

输入 

1
4

输出

1
4不是质数

3.2 求第n个斐波那契数

分析：斐波那契数列为： 1、1、2、3、5、8、13……，从第三个数开始，每个数的值等于前两个斐波那契数相加的值
f(x) = 1   [1，2]
f(x) = f(x-2) + f(x-1)   x>2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
int fibonacci_number(int n) {
	//从第三个数开始，每个数的值等于前两个斐波那契数相加的值
	//定义三个变量，n1代表第一个数,n2代表第二个数,n3代表第三个数即我们所求的数
	int n1 = 1;
	int n2 = 1;
	int n3 = 1;
	if (n <= 2)
	{
		return n3; //当求第1个或第2个斐波那契数时直接返回n3
	}
	else
	{
		int i = 0;
		for (i = 3; i <= n; i++) //i代表需要循环次数，由于前2个斐波那契数不需要求，所以i从3开始
		{
			n3 = n1 + n2; 
			n1 = n2;
			n2 = n3;
		}
	}
	return n3; 
}
int main(void) {
	int n = 0;
	printf("请输入需要求的第几个斐波那契数：》");
	scanf("%d", &n);
	printf("第%d个斐波那契数为：%d", n, fibonacci_number(n));
}

输入

1
7

输出

1
第7个斐波那契数为：13

四、函数调用

函数的调用就是函数的使用。函数调用通过使用函数调用运算符构成函数调用表达式实现。函数调用操作符是 ( )，函数调用表达式的一般形式：
  函数名(参数列表);
函数没有参数时，( )内为空就行

4.1实参与形参

实参：函数调用操作符中的参数称为实际参数，简称实参，每个实参前面没有类型说明符，传入实参类型与个数必要与对应函数定义里面的相同

形参：函数定义中（）内的参数叫做形式参数，简称形参。形式参数只有在函数调用的过程中才会分配内存空间。形参在函数调用完成后就会自动销毁。因此形参只会在函数中有效。本质上形参只是实参的一份临时拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int sum(int x, int y);
int main() {
	int result = 0;
	int a = 10;
	int b = 20;
	result = sum(a, b);  //这里的a和b是实参
	return 0;
}

int sum(int x, int y) { //函数这里传入的x和y是形参
	return x + y;
}

4.2传值调用与传址调用

以下通过这个案例演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
void swap(int x, int y) {//交换x和y的值
	int tmp = x;  
	x = y; 
	y = tmp;
}

int main(void) {
	int a = 10;
	int b = 20;
	printf("a与b交换前：a=%d b=%d\n", a, b);
	swap(a, b);
	printf("a与b交换后：a=%d b=%d\n", a, b);
}

输出

1
2
a与b交换前：a=10 b=20
a与b交换后：a=10 b=20

我们可以发现，调用swap函数，a和b的值却没有交换。这是因为此时我们是传值调用。
传值调用：形参和实参分别占用不同的内存区域，对形参的改变不会影响实参
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

我们可以发现，实参a和b 与 形参x和y占用不同内存地址，通过传入实参a、b对形参x、y赋值后，实参a、b和形参x、y就没有任何关系了，所以对x、y的值的修改并不会影响实参a和b

传址调用：把函数外部创建变量的内存地址传递给函数的形参。这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是通过函数内部可以操作函数外部的变量

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
void swap(int* px, int* py) {
	int tmp = *px;   //整形指针变量px存的是a的地址,整形指针变量py存的是b的地址
	*px = *py;     //通过*号 解引用操作符找到pa变量所指向地址空间（a的空间）并更改存储的值
	*py = tmp;		 //通过*号 解引用操作符找到py变量所指向地址空间（b的空间）并更改存储的值
}
int main(void) {
	int a = 10;
	int b = 20;
	printf("a与b交换前：a=%d b=%d\n", a, b);
	swap(a, b); //传入的是a与b的地址
	printf("a与b交换后：a=%d b=%d\n", a, b);
}

输出

1
2
a与b交换前：a=10 b=20
a与b交换后：a=20 b=10

在这里插入图片描述

简单来说，如果传入的是变量的地址就是传址调用，否则就是传值调用。当需要在函数内部改变外部变量的值时要使用传址调用

4.3嵌套调用和链式访问

嵌套调用：函数和函数之间可以根据实际的需求进行组合，即在函数内部调用另外一个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
void test1() {
	printf("欢迎访问我的博客\n");
}
void test2() {
	int i = 1;
	for (i = 1; i <= 5; i++)
	{
		test1(); //嵌套调用
	}
}
int main(void) {
	test2();
}

输出

1
2
3
4
5
欢迎访问我的博客
欢迎访问我的博客
欢迎访问我的博客
欢迎访问我的博客
欢迎访问我的博客

链式访问：把一个函数返回值作为一个函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int max(int x, int y) { //返回x与y的较大值
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}
int main(void) {
	int result = 0;
	result = max(100, max(10, 20)); //链式访问，将max(10,20)的返回值20作为参数传入max函数，即max(100,20)
	printf("%d\n", result);
}

输出

1
100

函数可以嵌套调用，但是不能嵌套定义（不能在一个函数内定义另外一个函数）