函数的参数
实际参数（实参）：
真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
形式参数（形参）：
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
上面Exchange1和Exchange2函数中的参数a，b，a，b 都是形式参数。在main函数中传给Exchange1的a,b和传给Exchange2函数的&a，&b是实际参数。
函数的调用
传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
Exchange1就是传值调用！
传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起正真的联系，也就是函数内部可以直接操作函数外部的变量。
Exchange2就是传址调用！
总结
如果我们要改变实参的值，我们就应该传递实参的地址，也就是传址调用！而传值调用，不会改变实参的值，因为形参只是实参的一份临时拷贝！
学到这，我们就可以尝试自己写几个函数了！
写一个函数可以判断一个数是不是素数。
写一个函数判断一年是不是闰年。
写一个函数，实现一个整形有序数组的二分查找。
写完了吗？来看看我写的吧！
//1.判断闰年 int is_leapyear(int x) { if (x % 4 == 0 && x % 100 != 0||x % 400 == 0) return 1; else return 0; } //二分查找 int binary_search(int* arr, int sz,int x) { int left = 0,right = sz - 1; while (left < right) { int mid = (left + right) / 2; if (arr[mid] > x) { right = mid - 1; } else if(arr[mid] { left = mid + 1; } else { return mid; } } return -1; } //判断素数 int is_prime_number(int x) { if (x < 2) return 0; int i = 0; for (i = 2; i <=sqrt(x); i++) { if (x % i == 0) return 0; } return 1; }
函数的嵌套调用和链式访问
函数和函数之间可以有机组合。
嵌套调用
void len_2() { printf("搞定C语言函数和递归！\n"); } void len_1() { int i=0; for(i=0;i<3;i++) len_2(); } int main() { len_1(); return 0; }
这便是函数嵌套，len_1函数里面嵌套了len_2函数！
链式访问
把一个函数的返回值作为另外一个函数的参数。
#include #include int main() { char arr[10]="abcd"; char*arr1=strlen(strcat(arr,"efgh")); printf("%s",arr1); return 0; }
注：strcat函数是将字符串"efgh"复制到arr1中，将arr的地址返回，strlen计算字符个数，细节请查阅文档！
所以strcat的返回值给了strlen函数，strlen函数的返回值，又给了printf函数，作为printf函数的参数！
我们再看个代码!
int main() { printf("%d",printf("%d",printf("%d",43))); }
注：printf函数的返回值是打印的字符个数，所以运行结果是:
4321
函数的声明和定义
函数的声明
告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。
函数的声明一般出现在函数的使用之前。要满足先声明后使用。
函数的声明一般要放在头文件中的。
函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。
#include //函数声明，告诉编译器存在这样一个函数 int Add(int x,int y); int main() { return 0; } //函数定义,函数的具体实现 int Add(int x,int y) { return x+y; }
上面是在一个文件中，并且我们知道函数先声明后使用！
其实我们也可以分文件进去函数的声明和定义！
头文件.h文件，放函数的声明！
源文件.c文件，放函数的定义！
有人就会问了，搞这么多文件干嘛！自己一个文件不好吗？这多麻烦啊！
我们再想一个问题，如果我们以后工作，小组要一起写一个程序。如果只有一个源文件，我们如何分配工作？
一个人写完，再给下一个人？
显然这样是不合理的，所以，这时多文件的优势就来了！
我们可以分工合作，一个人写一个函数文件，然后在.h文件声明一下就可以了！
分文件书写形式还有一个优势！
利于函数的封装和隐藏！
当我们给别人写了个程序时，我们将这程序的功能卖给别人，而有些重要的代码，商业机密，不能给他们看到。这就可以利用分文件的优势了！我们只卖功能不卖代码！
我们团队要给客户写一个计算机功能的程序
操作如下：
写add函数功能的函数库！
创建一个文件add
写一个add.h的头文件和add.c的源文件
再将文件属性，配置类型，改成静态库（.lib）
编译一下就生成一个.lib的文件！找到.lib文件和add.h文件打包卖给客户！
test_7_24.5就是客户，买到了add.lib文件和add.h文件！
我们将静态库Add.lib引用声明一下，便可以使用了！
函数的递归
什么是递归？
程序调用自身的编程技巧称为递归（recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把****大事化小！
递归的两个必要条件
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件！
接受一个整型值，按照顺序打印它的每一位！例如：输入：1234 输出：1 2 3 4
#include void print(int n) { if(n>9) //限制条件 { print(n/10); //接近限制条件 } printf("%d ", n%10); } int main() { int num = 1234; print(num); return 0; }
这就是使用函数递归解决该问题！
什么是入栈，出栈呢?
你是否想过，如果我们无限递归下去，一直开辟栈区的空间，是否会发生栈区内存空间不足！
所以递归的两个条件是很重要的！缺一不可，不然就会无限递归下去！
编写函数不允许创建临时变量，求字符串的长度。
这个题目怎么用递归实现呢？
我们要知道递归的思想就是大事化小！
让我我们多画图，便于学习递归思想！
int my_strlen(char* arr) { if(*arr!='\0') //限制条件 { return 1+my_strlen(arr+1); //调用接近限制条件 } else { return 0; } } #include int main() { char arr[]="abcdefg"; int len= my_strlen(arr); return 0; }
学会了吗！
你们可以尝试自己写几个递归的代码！
求n的阶乘。（不考虑溢出）
求第n个斐波那契数（不考虑溢出）
int factorial(int n) { if(n <= 1) return 1; else return n* factorial(n-1); } int fib(int n) { if (n <= 2) return 1; else return fib(n - 1) + fib(n - 2); }
但是我们发现有问题；
在使用fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
使用factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
为什么呢？
我们发现fib 函数在调用的过程中很多计算其实在一直重复。 如果我们把代码修改一下!
int count = 0;//全局变量 int fib(int n) { if(n == 3) count++; if (n <= 2) return 1; else return fib(n - 1) + fib(n - 2); }
最后我们输出看看count，是一个很大很大的值。
那我们如何改进呢？
在调试factorial 函数的时候，如果你的参数比较大，那就会报错：stack overflow（栈溢出）这样的信息。 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
那如何解决上述的问题：
将递归改写成非递归。
使用static对象替代nonstatic局部对象。在递归函数设计中，可以使用static对象替代nonstatic局部对象（即栈对 象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，
而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
你们可以试试！
int fib(int n) { if(n<3) { return 1; } else { int a=1; int b=1; int c=0; while(n>2) { a=b; b=c; c=a+b; n--; } return c; } }
提示：
3. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
4. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
5. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。
