手撕C语言初阶--函数

函数

函数是什么

数学中我们常见到函数的概念。但是你了解C语言中的函数吗？维基百科中对函数的定义：子程序

• 在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method,subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。
• 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

其实函数就是可以解决一类问题的解决方法，如果适合我们可以重复使用。

前面学习C语言大家可能习惯把代码都写在main函数内，今天学习了函数之后如果对一类问题的解决会使用重复的代码，我们就可以把这段代码封装成函数，这样即提高了效率又提高了代码的可读性

C语言中函数的分类：

1. 库函数
2. 自定义函数

库函数
为什么会有库函数？
3. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
4. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
5. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。

像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

那怎么学习库函数呢？
这里我们简单的看看：https://www.cplusplus.com/reference/

这是一个学习C库函数的网站，如果大家有不懂的库函数就可以来这里查询。
例如我们要搜索strlen这个库函数

搜索之后我们就来到了这个界面：

简单的总结，C语言常用的库函数都有：

• IO函数
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

注： 但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。

自定义函数

如果库函数能干所有的事情，那还要程序员干什么？

所以更加重要的是自定义函数。

自定义函数和库函数一样，有函数名，返回值类型和函数参数。 但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

函数的组成：

ret_type fun_name(para1, * )
{
    statement;//语句项
}
    //ret_type 返回类型
    //fun_name 函数名
    //para1 函数参数

例如：我们写一个函数来求两个数中的最大值

#include <stdio.h>
//get_max函数的设计
int get_max(int x, int y)
{
    return (x>y)?(x):(y);
}

int main()
{
    int num1 = 10;
    int num2 = 20;
    int max = get_max(num1, num2);
    printf("max = %d\n", max);
return 0;
}

这个问题对于大家来说肯定是小菜一碟，那我们再来一个问题
写一个函数，交换两个数

#include <stdio.h>
void Swap1(int x, int y)
{
    int tmp = 0;
    tmp = x;
    x = y;
    y = tmp;
}

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

大家是不是和我写的一样呢？我们一起来看一看得出的结果：

诶？这是怎么回事啊？我们的代码没问题啊，思路很清晰啊，怎么结果会不对呢？
其实在这里在函数传参时传入的是a和b的值(称为传值调用)，而函数在传值调用时会在内存中重新创建两块空间用来保存a和b的值，然后再在创建的空间中将两个数交换，而在a和b原来的空间中它们并没有交换。

就比如有两个盒子a，b，a盒子放10，b盒子放20，如果是传值调用，进入函数后会重新再拿两个盒子c，d，c盒子放10，d盒子放20，然后将他们交换，这样其实a和b盒子中的数并没有发生任何变化。

所以在这里如果我们希望传入的参数发生改变，我们就需要进行传址调用
函数在进行传址调用时，就不会创建新的空间，而是根据传过来的地址找到a和b的值将他们交换

void Swap2(int *px, int *py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}

int main()
{
    int num1 = 1;
    int num2 = 2;
    printf("交换前：a = %d b = %d\n", a, b);
    Swap2(&num1, &num2);
    printf("交换后：a = %d b = %d\n", a, b);
return 0;
}

注意：传址调用时对应的参数我们需要用指针来接收

函数的参数

实际参数（实参）：
真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形式参数（形参）：
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

上面Swap1和Swap2函数中的参数 x，y，px，py 都是形式参数。在main函数中传给Swap1的num1，num2和传给Swap2函数的&num1，&num2是实际参数。

然后我们对刚才上面的问题进行分析：

在传值调用时，我们通过对a和x及b和y的内存查看发现他们的地址不相同，所以他们在交换时使用的不是同一块空间，所以达不到我们预期的效果。

而在传值调用时，a和px，b和py的地址相同，则在交换时使用的是同一块空间，就可以达到形参控制实参从而使实参发生变化的效果。

函数的调用：

传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用

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

函数的嵌套调用和链式访问

函数和函数之间可以有机的组合的。

函数的嵌套调用
顾名思义即在函数内部调用函数

#include <stdio.h>
void new_line()
{
    printf("hehe\n")
}
void three_line()
{
    int i = 0;
    for(i=0; i<3; i++)
    {
    new_line();//函数内部调用函数
    }
}
int main()
{
    three_line();
    return 0;
}

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

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
    int ret = strlen(strcat(arr,"world"));//将strcat函数的返回值作为strlen的参数
    printf("%d\n", ret);
    return 0;
}

函数的声明和定义

函数声明：

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。

函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。

#pragma once//防止头文件被重复包含
//函数的声明
int Add(int x, int y);

#include "test.h"//包含函数声明所在的头文件
//函数Add的实现
int Add(int x, int y)
{
return x+y;
}

注：这里的分文件书写的形式我们后面再进行介绍

函数递归
什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序
设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小。

递归的两个必要条件

• 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
• 每次递归调用之后越来越接近这个限制条件。

练习1：接受一个整型值（无符号），按照顺序打印它的每一位。 例如： 输入：1234，输出 1 2 3 4

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

这里用这张图片里的步骤解释函数的调用，我们可以发现仅仅只用了少量的代码就完成了这四步的打印，而用其他方法，则需要更多的代码。

练习2：求第n个斐波那契数。（不考虑溢出）(斐波那契数：即第一个数为 1，第二个数为 1 ，后面的每个数等于前面两个数之和)

int fib(int n)
{
    if (n <= 2)
    return 1;
    else
    return fib(n - 1) + fib(n - 2);
}

我们来验证一下，例如第三个斐波那契数为2，我们输入3

那如果我们要输出第50个斐波那契数呢，我们来输入50

就会出现这种情况，程序运行了很久都没有输出结果，这是为什么呢？

按照递归的思路，我们在求第50个斐波那契数的时候需要算出，第49个和第48个，而在算第49和第48个的时候，需要分别算出48，47和47，46；一直这样循环下去直到算到第一个和第二个，这其中会算很多个重复的数字，所以会算很多次，导致程序运行的时间会很长。

所以在计算这类问题时，使用递归就不那么方便了，这里我们可以使用函数的另一个知识点迭代

这样计算次数会大大减少，减少了程序运行时间

int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n > 2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	printf("%d", fib(n));
	return 0;
}

（注：在计算的数很大时可能会超出类型所能存储的最大范围）

结论：

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

到这里本章函数的部分就结束了，大家一定要多多练习，多刷刷题，巩固所学到的知识，一起努力，我们下章再见！

多多点赞哦~~