函数探秘：深入理解C语言函数，实现高效模块化编程

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C语言学习
贝蒂的主页：Betty‘s blog

1. 函数的概念

在数学中我们就知道了函数这个概念，而C语言同样引入了函数这个概念，那C语言的函数到底是什么样的呢？

在C语言中，函数也叫子程序，它是一段可以重复使用的代码，用来独立地完成某个功能，它可以接收用户传递的数据，也可以不接收。

2. 函数的分类

C语⾔的程序其实是由⽆数个⼩的函数组合⽽成的，也可以说：⼀个⼤的计算任务可以分解成若⼲个较⼩的函数（对应较⼩的任务）完成。同时⼀个函数如果能完成某项特定任务的话，这个函数也是可以复⽤的，提升了开发软件的效率。而C语言函数大致可以分为两类：库函数与自定义函数

2.1 库函数

C语⾔标准中规定了C语⾔的各种语法规则，但是C语⾔并不提供库函数；C语⾔的国际标准ANSIC规定了⼀些常⽤的函数的标准，被称为标准库，那不同的编译器⼚商根据ANSI提供的C语⾔标准就给出了⼀系列函数的实现。这些函数就被称为库函数。

比如说我们前面学习的printf和scanf都是库函数，它的头文件时<stdio.h>。但是我们今天的主题不是讲解库函数，如果大家想学习其他库函数，可以去C/C++官方学习

2.2 自定义函数

自定义函数是由程序员自主设计的函数，和库函数一样有函数名、返回类型、形式参数等，今天我们的目标就是学习如何写自定义函数。

3. 自定义函数

3.1 语法

dataType functionName(形式参数)

{
//body
}

dataType 是返回值类型，它可以是C语言中的任意数据类型，例如 int、float、char 等。
functionName 是函数名，它是标识符的一种，命名规则和标识符相同。函数名后面的括号( )不能少。
body 是函数体，它是函数需要执行的代码，是函数的主体部分。即使只有一个语句，函数体也要由{ }包围。
如果有返回值，在函数体中使用 return 语句返回。return 出来的数据的类型要和 dataType 一样。

3.2 实例

通过函数的定义我们可以写一个简单的加法函数：

#include<stdio.h>
int Add(int x, int y)
//函数名Add
//两个形式参数x,y，类型都是int
//返回类型也是int
{
	int c = 0;
	c = x + y；
	return c;//返回x+y的和
}
int main()
{
	int a, b;
	scanf("%d%d", &a, &b);
	int ret = Add(a, b);//加法函数
	printf("两个数和为%d\n", ret);
	return 0;
}

当然我们也可以优化一下

int Add(int x, int y)
{
	return x + y;//直接返回
}

通过函数我们就可以节省大量时间，每次调用这个功能只需复用该函数即可。

3.3 作用域与生命周期

作用域和生命周期是C语言中一个特别重要的概念，清楚理解这个概念能帮助我们写出更好的程序，减少bug的产生。

作⽤域（scope）是程序设计概念，通常来说，⼀段程序代码中所⽤到的名字并不总是有效（可⽤的，⽽限定这个名字的可⽤性的代码范围就是这个名字的作⽤域。

局部变量的作⽤域是变量所在的局部范围。

全局变量的作⽤域是整个⼯程（项⽬）。

以上面加法函数以列，x，y的作用域就是加法函数。当加法函数执行结束，它就会被销毁。

⽣命周期指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的⼀个时间段。

局部变量的⽣命周期是：进⼊作⽤域变量创建，⽣命周期开始，出作⽤域⽣命周期结束。

全局变量的⽣命周期是：整个程序的⽣命周期。

以上面加法函数以列，x，y的生命周期就是其进入函数创建到变量销毁的时间段。

4. 函数的参数

在函数使⽤的过程中，把函数的参数分为，实际参数和形式参数。下面我仍将以加法函数举例：

#include<stdio.h>
int Add(int x, int y)
//函数名Add
//两个形式参数x,y，类型都是int
//返回类型也是int
{
	int c = 0;
	c = x + y；
	return c;//返回x+y的和
}
int main()
{
	int a, b;
	scanf("%d%d", &a, &b);
	int ret = Add(a, b);//加法函数
	printf("两个数和为%d\n", ret);
	return 0;
}

4.1 实际参数

顾名思义，实际参数就是实际存在的参数，也就是主函数main调用函数时传给它的参数，也就是上面主函数中的a，b。

4.2 形式参数

同理，形式参数其实就是形式上的参数，也就是上面加法函数Add中的x，y。它并不是实际存在的，在未使用时并不会向内存申请空间，形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，这个过程就是形式的实例化。

4.3 实参与形参的关系

在介绍实参和形参关系时，我们先看看下面这段代码

#include<stdio.h>
void swap(int x, int y)//返回类型为void表示不返回值
{
    int temp = 0;//定义一个临时变量
    temp = x;//把x的值赋给temp
    x = y;//把y的值赋给x
    y = temp;//把temp的值赋给y，完成交换操作
}
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;
}

那么交换后的输出是多少呢~

为什么交换的值还是不变呢，我们可以通过调试来观察一下

通过调试，我们发现a与x，b与y只是在数值上相同，他们地址是完全不同的，他们在两个独立的内存空间互不影响，对x，y交换根本不会改变a，b的值。并且函数在调用完成之后，函数所申请的内存空间会归还系统~

所以我们总结实参与形参的关系是：形参只是实参的⼀份临时拷⻉，对形参改变根本不会影响实参

4.4 数组做参数

我们前面学过的数组自然是也能作为函数的参数来使用，下面是一个具体实例：

void print_arr(int arr[], int sz)//打印数组
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

其中arr是整个数组，sz是数组元素的个数

5. 嵌套调用和链式访问

5.1 函数的嵌套调用

我们在前面已经学习了选择结构和循环结构的嵌套使用，那函数嵌套调用又是怎样的呢。其实，简单来说，就是函数中也可以调用函数

举个例子，让我们看看下面这段代码

void print2()
{
	printf("hello world\n");
}
void print1()
{
	print2();//调用print2函数
}
int main()
{
	print1();//调用print1函数
         return 0;
}

C语言函数支持嵌套调用，但是不支持嵌套定义。

5.2 函数的链式访问

链式访问简单来说就是将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数的链式访问。

举例：

这是strlen的函数声明：size_t strlen(const char *str)

#include <stdio.h>
int main()
{
	printf("%d\n", strlen("abcdef"));
    //根据strlen的返回值，我们就可以直接将其作为printf的参数
    //这就是一种简单的链式访问
	return 0;
}

6.函数的定义与声明

6.1 函数的定义

函数的定义就是指函数具体的实现过程，交代函数具体功能的实现

比如我们前面写的加法函数具体实现的过程就是函数的定义

int Add(int a, int b)
{
	return a + b;//直接返回
}

但是特别注意函数不能嵌套定义

int add(int x, int y)//加法函数
{
    return x + y;
    void print()
    {
        ....;//嵌套定义error
    }
}

6.2 函数的声明

不知道大家注意到一个细节没有，就是贝蒂在写函数时候，会把函数放在主函数之前，那如果放在主函数之后会怎么样呢，让我们实验一下吧

int main()
{
	int a, b;
	scanf("%d%d",&a,&b);
	int ret = Add(a, b);
	printf("%d", ret);
	return 0;
}
int Add(int x, int y)
{
	return x + y;
}

一运行就会报这个警告，这个警告的意思就是说Add函数未定义，那为什么说Add未定义呢，原来是程序从上往下进行的，在遇到Add函数之前，会先执行主函数中的Add，此时程序根本不知道Add的含义，所以会报警告。

那如何消除这个警告呢，其实我只需要加一个声明，让程序提前知道有这个函数。

int Add(int x, int y);//函数声明
int main()
{
	int a, b;
	scanf("%d%d",&a,&b);
	int ret = Add(a, b);
	printf("%d", ret);
	return 0;
}
int Add(int x, int y)
{
	return x + y;
}

int Add(int , int );//声明写出这样也是可以的

函数的调⽤⼀定要满足，先声明后使⽤是，而函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。

7. 函数的迭代与递归

7.1 函数的迭代

「迭代 iteration」是一种重复执行某个任务的控制结构。在迭代中，程序会在满足一定的条件下重复执行某段代码，直到这个条件不再满足。我们学习过的while，for，do-while循环结构就是一种迭代。

7.2 函数的递归

「递归 recursion」是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段。

递：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。

归：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。

递归的三个要素:

终止条件：用于决定什么时候由“递”转“归”。

递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。

返回结果：对应“归”，将当前递归层级的结果返回至上一层。

7.3 递归问题

(1) 问题一

利用递归计算1+2+3+4+....+n

int recur(int n)
{
	// 终止条件
	if (n == 1)
	{
		return 1;
	}
	// 递：递归调用
	return n + recur(n - 1);
}

(2) 问题二

输⼊⼀个整数m，打印这个按照顺序打印整数的每⼀位。
⽐如：
输⼊：1234 输出：1 2 3 4
输⼊：520 输出：5 2 0

#include <stdio.h>
void print(int n)
{
    if (n > 9)
    {
        print(n / 10);
    }
    printf("%d ", n % 10);
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    print(n);
    return 0;
}

代码分析：

void print(int n)//输入1234
{
    if (n > 9)//1234大于9
    {
        print(n / 10);//将123传入下个递归
    }
    printf("%d ", n % 10);//归的第四步，输出4
}
void print(int n)//传入123
{
    if (n > 9)//123大于9
    {
        print(n / 10);//将12传入下个递归
    }
    printf("%d ", n % 10);//归的第二步，输出3
}
void print(int n)//传入12
{
    if (n > 9)//12大于9
    {
        print(n / 10);//将1传入下个递归
    }
    printf("%d ", n % 10);//归的第一步，输出2
}
void print(int n)//传入1
{
    if (n > 9)//1不大于9
    {
        print(n / 10);
    }
    printf("%d ", n % 10);//输出1，开始‘归’
}

posted @ 2024-02-24 23:38 Betty’sSweet 阅读(259) 评论(0) 编辑收藏举报

刷新页面返回顶部

bett