C语言函数详解——一文带你入门函数~

C语言基础

本文主要讲解函数的基本使用和递归

---

---

一、函数是什么？

数学中我们常见到函数的概念，但是你了解C语言中的函数吗？

在计算机中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某个特定任务，实现某个功能，并且相较于其他代码块，具备相对的独立性。
这里的独立性是指高内聚，低耦合的特性，即函数内聚就是模块内部之间的联系，耦合就是模块与模块之间的联系。
高内聚是加强模块内部之间的联系，使得模块内部的数据紧密性很强，没有其他相关度小的数据影响，让模块的独立性极大提高，如果一个模块的内聚性低，说明模块内部有很多其他数据，那么改动的时候就会影响到其他数据牵扯到的模块。
低耦合就是要尽量减少模块与模块之间的联系，使得调用一个模块时没必要去考虑其他模块是否受影响，因为他们之间独立性很强。

二、C语言中函数的分类：

1、库函数

像我们学习编程时，总是频繁的使用到诸如printf()、scanf()、rand()之类的函数，这些函数是C语言基础库中提供的。
但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。

C语言常用的库函数：
IO函数
字符串操作函数
字符操作函数
内存操作函数
时间/日期函数
数学函数
其他库函数

如何学会使用库函数？掌握下面这几个查询工具：
www.cplusplus.com
https://en.cppreference.com

2、自定义函数

当然，库函数不是万能的，总有库函数办不到的事情，程序员的岗位也就应运而生了。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。但是不一样的是这些都是我们自己设定的。
举个栗子：

//get_max函数的设计
int get_max(int x, int y) 
{
 return (x>y)?(x):(y);
}
//int        返回类型
//get_max    函数名
//x、y       函数参数

三、函数参数

1.实际参数（实参）

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

2、形式参数（形参）

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

#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函数中的参数 x，y，px，py 都是形式参数。在main函数中传给Swap1的num1，num2和传给Swap2函数的&num1、&num2是实际参数。
这里我们对函数的实参和形参进行分析：

这里可以看到Swap1函数在调用的时候，x，y拥有自己的空间，同时拥有了和实参一模一样的内容。所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。因此在swap1中虽然交换了x和y的值，但并不会交换num1和num2的值。
但Swap2函数不同，修改它的参数值也会交换主函数中两个变量的值，这里要引入一个新的知识点：函数的两种调用方式。

四、函数的调用

1、传值调用

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

2、传址调用

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

再来分析一下上面代码的内存分配：

可以看到，因为Swap2函数形参实例化后，存放的是num1 num2的地址，虽然也会开辟新的空间，但是修改时修改的是指针所指地址中的值。

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

相信你一定写过代码中有输入输出的函数吧，这就是嵌套调用，函数与函数之间是可以有机组合的。

（1）嵌套调用

嵌套调用：在一个函数中调用另一个函数

代码如下（示例）：

#include <stdio.h>
void Cx()
{
 printf("hehe\n");
}
void Xhcx()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        Cx();
   }
}
int main()
{
 Xhcx();
 return 0;
}

主函数调用Xhcx，然后Xhcx中又调用了三次Cx函数，这就使嵌套调用。

（2）链式访问

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

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr,"bit"));//这里介绍一下strlen函数:需要引入string.h头文件，用于求字符串长度
 printf("%d\n", ret);
 return 0;
}
#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
 //输出4321
    return 0;
}

printf()函数的返回值是字符串的长度，因此最内层的printf("%d",43)打印输出43后返回值为2作为第二层的printf的输入，以此类推 就是链式调用。

五、函数的声明和定义

1、函数声明：

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

2、函数定义：

函数的定义是指函数的具体实现，交代函数的功能实现。
若函数定义在使用之前，不声明也可以，但当一个程序很庞大时，会有很多的函数，并且又包含着各种各样的嵌套，很难去理清程序的执行顺序，因此先声明是很必要的。

函数的声明一般放在头文件<####.h>中。
具体实现的方式放在源文件###.c文件中 。

六、函数的递归与迭代！！！

函数的灵魂

1、什么是递归？

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

2、递归的两个必要条件

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

先看代码：

//这是一段求累加和的代码
#include <stdio.h>
int sum（int n）
{
	if (n==1)
		return 1;
	return n+=sum(n-1);
}
int main()
{
	int n=5
	printf("%d",sum(n));
}

再来看程序的执行过程：

再求5的累加和时，先把问题拆分成5+4的累加和，继而拆分成5+4+3的累加和…直到n==1，依次返回函数值作为上一层迭代的输入。
正如上面所说的，递归函数只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。但这种代码量上的优势是需要付出成本的：巨大的空间成本。
再来看一段代码：

//求斐波那契数列
#include <stdio.h>
int fib(int n)
{
 if (n <= 2)         
 return 1;
    else
    return fib(n - 1) + fib(n - 2);
}
int main()
{
	int n=50;
	printf("%d",fib(n));
}

运行这段程序，你会发现：在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
为什么呢？
因为fib 函数在调用的过程中很多计算其实在一直重复。 如果我们把代码修改一下：

#include <stdio.h>
int count = 0;//全局变量
int fib(int n)
{
 if(n == 3)
 count++;
 if (n <= 2)         
 return 1;
    else
    return fib(n - 1) + fib(n - 2);
}
int main()
{
	int n=50;
	printf("%d",fib(n));
	printf("%d",count);
}

最后我们输出看看count，是一个很大很大的值。因为递归调用时，计算第五项需要知道第三第四项的值，计算第四项有需要知道第二第三项的值，这里的第三项就被计算了两次。或者说除了前两项和最后两项，每一项都被计算了两次。

在调试 fib 函数的时候，如果你的参数比较大，那就会报错： `stack overflow（栈溢
出） 这样的信息。 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递
归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢
出。

如何解决这个问题呢？

1. 将递归改写成非递归。
2. 使用static对象替代nonstatic局部对象。在递归函数设计中，可以使用static对象替代nonstatic局
   部对象（即栈对 象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
   但一般情况下，通常采取的解决办法是采用第一种，至于为啥不用第二种，老师没细讲不是很明白。

3、函数的迭代

什么是迭代？
通俗的讲迭代就是循环，迭代法也称辗转法，是一种不断用变量的旧值递推新值的过程，即在程序执行过程中不断更新传入函数的参数，从而得到自己想要的结果。这个在神经网络种用到很多，各种模型都是通过迭代得到的。
举个栗子：

#include <stdio.h>
#include <stdlib.h>
int maxgys(int a,int b) //函数原型声明(最大公因数）
{
    while(b!=0)         //函数实现
    {
        int r;
        r=a%b;
        a=b;
        b=r;
    }
    return a;
}
int main()
{
    int a,b;
    scanf("%d %d",&a,&b);
    printf("%d",maxgys(a,b));
    return 0;
}

这是求两个数最大公因数的代码，通过不断迭代更新a的值最终得到a、b的最大公因数。

---

总结

以上就是今天要讲的内容，本文只是简单介绍了C语言种的函数，算是一篇函数入门吧~ 后面学了指针、数组以后，再能把函数的使用进阶一下！
PS：写了一整个下午QAQ 铁子们觉得写的还行的话，支持一下！阿里嘎多~