【C】掌握函数基本知识+理解函数递归

✨博客主页:心辛向荣
✨系列专栏:【从0到1，C语言学习】
✨一句短话:你若盛开，蝴蝶自来！
✨博客说明:尽己所能，把每一篇博客写好，帮助自己熟悉所学知识，也希望自己的这些内容可以帮助到一些在学习路上的伙伴，文章中如果发现错误及不足之处，还望在评论区留言，我们一起交流进步！😊

---

💻前言

🍁在学习编程过程中，函数的使用可以让我们的代码逻辑更加简易清晰，所以对于函数的使用方法和理解为什么要使用函数是非常重要的。
🍁这篇博客会总结函数当中的需要注意的知识点，助大家学习理解、正确运用函数。

---

💻目录

一.函数的概念
二.函数的分类
——1.库函数
———讲解如何学习库使用库函数
——2.自定义函数
三.函数的参数和调用
——1.实际参数(实参)
——2.形式参数(形参)
——3.函数的传值调用与传址调用
———传值与传址的对比实例
———写一个函数，实现一个整形有序数组的二分查找。
四.函数的嵌套调用和链式访问
——1.嵌套调用
——2.链式访问
五.函数的声明和定义
——如何理解函数的声明一般要放在头文件中的
六.函数递归
——1.什么是递归？
——2.递归的俩个必要条件
——3.图解理解递归
——4.递归与迭代

---

💻一.函数的概念

维基百科中对函数的定义：子程序

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

---

💻二.函数的分类

1.库函数

为什么会有库函数？

1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
   像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

C语言当中的库函数库函数并不需要全部进行记忆，库函数的学习碰到一个学习一个即可，那么下面介绍如何学习库函数。
使用库函数，必须包含 #include 对应的头文件。
我们可以参照文档进行学习，文档链接：http://www.cplusplus.com/

• 这里参照文档学习俩个库函数（strcpy和memset），助大家掌握库函数的学习方法，注意我们的英文水平也很重要，起码要能看懂文献

我们学习过程中的资源文献大部分都是英文的，英语不好怎么解决呢，我本人就英语特别差，不过办法总比困难多，浏览器里下一个插件也能对付着学不是，当然英语差归差，但也不能不学，哈哈。
🌸strcpy函数使用实例

#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[30] = { 0 };
	char arr2[] = "tryjdc";

	strcpy(arr1,arr2);

	printf("%s %s\n",arr1,arr2);

	return 0;
}

这个函数此时的效果是，将arr2中的字符串复制到arr1

🌸memset函数使用实例

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[20] = "tryjdc";

	memset(arr, 'y', 3);
	printf("%s\n", arr);

	return 0;
}

所以这个函数此时的效果是，从arr指向的元素开始，往后的3个元素替换成y

2.自定义函数

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

写一个函数可以找出两个整数中的最大值。

#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;
}

---

💻三.函数的参数和调用

1.实参

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

2.形参

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


当代码进入调试状态，打开监视窗口，我们可以看到实参num1、num2和形参x、y拥有相同的值；但形参x、y是与实参的地址不同的，也就是说，在函数调用时，形参x、y拥有自己独立的空间，所以，可以总结为：形参实例化之后其实相当于实参的一份临时拷贝。

3.函数的传值调用与传址调用

🌸传值调用

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

🌸传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

写一个函数可以交换两个整形变量的内容（传值与传址的对比实例）。

#include <stdio.h>
//实现成函数，但是不能完成任务
void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}

//正确的版本
void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}

int main()
{
	int num1 = 1;
	int num2 = 2;

	Swap1(num1, num2);//传值
	printf("Swap1::num1 = %d num2 = %d\n", num1, num2);

	Swap2(&num1, &num2);//传址
	printf("Swap2::num1 = %d num2 = %d\n", num1, num2);

	return 0;
}

可以看到swap1函数并没有实现交换，这里是因为形参和实参在内存中都拥有自己独立的空间，此时对于形参的改变并不会影响到实参；而swap2函数可以实现交换。
总结：不通过自定义函数改变外部变量的值时使用传值调用，当我们想要通过函数改变外部变量时就使用传址调用。

写一个函数，实现一个整形有序数组的二分查找。

int binary_search(int arr[], int k, int sz)//形参arr看上去是数组，本质是指针变量
{
	int left = 0;
	int right = sz - 1;

	while (left<=right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;//找到了返回下标
		}
	}

	return -1;//找不到
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	//            0 1 2 3 4 5 6 7 8 9 
	int k = 7;
	int sz = sizeof(arr) / sizeof(arr[0]);

	//找到了，返回下标
	//找不到，返回-1

	int ret = binary_search(arr, k, sz);
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是:%d\n", ret);
	}

	return 0;
}

这个代码的易错点在于，在求数组的长度时千万不能在自定义函数内部去求，数组传参实际上传递的是数组首元素的地址而不是整个数组，所以在自定义函数内部计算一个函数参数部分的数组的元素个数是错误的。

---

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

函数和函数之间可以根据实际的需求进行组合的，也就是函数之间可以互相进行调用。

1.嵌套调用

函数可以嵌套调用，但是不能嵌套定义。

#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;
}

2.链式访问

把一个函数的返回值作为另外一个函数的参数。

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[20] = "tryjdc";
	int ret = strlen(strcat(arr, "xxjdnl"));
	printf("%s\n", arr);
	printf("%d\n", ret);

    printf("%d\n",printf("%d",printf("%d",43)));//从内层向外层执行
	return 0;
}

strlen函数的返回值是字符串的长度,printf函数的返回值是打印在屏幕上字符的个数

---

💻五.函数的声明和定义

函数声明：

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

初学者在学习编程写代码的时候由于代码量少为了方便我们会把所有的代码都是写在一个源文件当中，那么我们的自定义函数和函数声明是这样写的：

#include<stdio.h>

int add(int, int);//函数声明

int main()
{
	int x = 6, y = 8;
	printf("%d\n",add(x,y));
	return 0;
}

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

如果自定义函数放在主函数前，则不需要进行函数声明:

include<stdio.h>

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

int main()
{
	int x = 6, y = 8;
	printf("%d\n",add(x,y));
	return 0;
}

那么为什么说函数的声明一般要放在头文件中的，我们可以这样想，当我们的代码量慢慢的变的很长时，如果所以代码都写在一个源文件当中，代码的逻辑会显得很乱，逻辑就没有那么清晰，代码的修改可能也会不方便；而且在未来就业以后，很多时候一个项目并不是一个人完成的，每个人可能只是负责其中的一部分功能实现，这个时候代码不可能只写在一个文件中，这样就需要将每个人写出的代码组在一起。

我们在学习过程中要考虑将代码模块化，从协作的角度去考虑问题，进而去实现问题。

这里通过一个简单的例子助大家理解：

这里比如程序员A写了一个加法函数add.c，把声明放在头文件add.h;而程序员B写了一个减法sub.c和sub.h;这样在text.c文件中就可以引上俩个头文件，然后就可以调用另外俩人写的内容实现使用。

其实这样模块式的代码可以一定程度上实现对代码的保护，如果我们的代码要给其他人使用但不不想让他们知道自己的代码是怎么实现的，我们可以将代码编译成一个静态库，这样把这个静态库和头文件交给其他人使用，他们只有使用权，而不会看到源码。

例如将一个加法功能的代码编译成静态库，做法如下：

而只要有静态库和对应的头文件这个功能就可以提供给其他人使用，只需要将静态库和头文件放到项目中，然后导入头文件和静态库就可以根据头文件中的声明进行使用！

把这个静态库文件(.lib)用记事本打开会发现都是一些二进制序列的乱码，所以可以对我们的代码起到保护作用。

函数定义：

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

函数的定义要自己设计函数名，返回值，函数的参数部分等，下面对比几种语法正确，但不推荐使用的写法，助大家避坑！

int Add(int x, int y)//不推荐
{
	printf("hehe\n");
}
//没有写return语句。
//上面的代码在一些编译器上返回的是函数中执行过程中最后一条指令执行的结果
int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	printf("%d\n", c);

	return 0;
}


void test()
{
	printf("hehe\n");
}
int main()
{
	test(100);//调用这个函数不需要传参使用，但可以传没有影响，不推荐
	test();//推荐

	return 0;
}


void test(void)
{
	printf("hehe\n");
}
int main()
{
	test(100);//不推荐的
	test();


	return 0;
}






int main(void)//明确的说明，main函数不需要参数
{

	return 0;
}

//本质上main函数是有参数的，main函数有3个参数，目前了解即可
int main(int argc, char* argv[], char *envp[])
{

	return 0;
}

---

💻六.函数递归

1.什么是递归

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

2.递归的俩个必要条件

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

3.图解理解递归

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

将这个问题由大化小，先想办法按顺序打印123，再打印4；
而123又可以考虑先打印12，再打印3；
12又拆为1和2，这样就把一个问题“大事化小”。

#include<stdio.h>

void print(int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ",n % 10);

}

int main()
{
	int num = 0;
	printf("请输入一个整数:>");
	scanf("%u",&num);

	print(num);

	return 0;
}

编写函数不允许创建临时变量，求字符串的长度。

一个字符串abcd,可以看作1+bcd的长度……

//递归
#include<stdio.h>

int Strlen (char* str)
{
	if (*str == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + Strlen(str + 1);
	}

}
int main()
{
	printf("输入一个字符串:>");
	char arr[30] = { 0 };
	scanf("%s", arr);
	int ret = Strlen(arr);
	printf("字符串的长的:>%d\n", ret);
	return 0;
}

//非递归
#include<stdio.h>

int Strlen(char *str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;	
}

int main()
{
	printf("输入一个字符串:>");
	char arr[30] = { 0 };
	scanf("%s",arr);
	int ret = Strlen(arr);
	printf("字符串的长的:>%d\n",ret);
	return 0;
}

2.递归与迭代

循环是迭代的一种，但迭代不一定是循环

递归和非递归分别实现求n的阶乘（不考虑溢出的问题）

非递归
#include<stdio.h>

int main()
{
   int i = 0,n = 0;
   int sum = 1;
   printf("n = ");
   scanf("%d",&n);

   for (i = 1; i <= n; i++)
   {
   	sum *= i;
   }
   
   printf("n的阶乘为:>%d\n",sum);

   return 0;
}

递归
#include<stdio.h>

int factorial(int n)
{
   if (n == 1)
   {
   	return 1;
   }
   if (n > 1)
   {
   	return n * factorial(n - 1);
   }
}

递归和非递归分别实现求第n个斐波那契数
例如：
输入：5 输出：5
输入：10， 输出：55
输入：2， 输出：1

//递归
#include<stdio.h>//1 1 2 3 5 8 13 21

int fib(int n)
{
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		return fib(n - 1) + fib(n - 2);
	}
}
int main()
{
	int n = 0;
	printf("n = ");
	scanf("%d",&n);

	int ret = fib(n);

	printf("第%d个斐波那契数为:>%d\n",n,ret);
	return 0;
}

//非递归

#include<stdio.h>//1 1 2 3 5 8 13 21
                            //a b c
int fib(int n)
{
	int i = 1, a = 1, b = 1,c = 0;
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		for (i = 1; i <= n - 2; i++)
		{
			c = a + b;
			a = b;
			b = c;
		}
		return c;
	}
}
int main()
{
	int n = 0;
	printf("n = ");
	scanf("%d", &n);

	int ret = fib(n);

	printf("第%d个斐波那契数为:>%d\n",n, ret);
	return 0;
}

这俩个例子在使用递归求解的时候会出现问题：

• 在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候，fib 函数在调用的过程中很多计算其实在一直重复，特别耗费时间。
• 使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
• 在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）这样的信息。系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
  

那如何解决上述的问题：

1. 将递归改写成非递归。
2. 使用static对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

提示：

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

---

💻结语

各位小伙伴，看到这里就是缘分嘛，希望我的这些内容可以给你带来那么一丝丝帮助，可以的话三连支持一下呗（关注✌️点赞✌️评论✌️）！！！
感谢每一位走到这里的小伙伴，我们可以一起学习交流，一起进步！！！加油！！！