1. 函数是什么 ？

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

2. 库函数

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

  1. #include <stdio.h>
  2. #include<string>
  3. int main(){
  4.     char arr[] = "hellow word";
  5.     //将arr字符串的前五个字符替换成*
  6.     memset(arr,'*',5);
  7.     printf("%s\n",arr);
  8.     /*输出结果：***** word  */
  10. }

3. 自定义函数

返回类型+函数名+函数体（+返回值）

  1. int getMax(int a,int b){
  2.     if(a>b){
  3.         return a;
  4.     }else{
  5.         return b;
  6.     }
  7. }
  8. #include<stdio.h>
  9. int main(){
  10.     int x = 2;
  11.     int y = 3;
  12.     int max = getMax(x,y);
  13.     printf("%d\n",max);
  14. }

4. 函数参数

实参：真实传给函数的参数，叫实参。 实参可以是：常量、变量、表达式、函数等。 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形 参。
形参：形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内
存单 元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有
效。

  1. /*使用函数交换两个数字*/
  2. #include<stdio.h>
  3. void swit1(int x, int y) {
  4.     int temp = 0;
  5.     temp = x;
  6.     x = y;
  7.     y = temp;
  8. }
  9. void swit2(int* px,int* py) {
  10.     int temp = 0;
  11.     temp = *px;
  12.     *px = *py;
  13.     *py = temp;
  14. }
  16. int main() {
  17.     int a = 100;
  18.     int b = 200;
  21.     int* pa = &a;
  22.     int* pb = &b;
  23.     swit2(pa,pb);
  24.     printf("交换后，数字a为：%d \n", a);
  25.     printf("交换后，数字b为：%d\n", b);
  26. }
  27. /*
  28. swit1没有交换数，是因为实参a，b与形参x，y的内存地址不一样，确实x和y的值交换了，但是和ab并没有关系，所以swit2在传递参数的时候，将ab的参数地址传递给了xy，那么xy在交换的时候，同时也就相当于交换的是ab了
  29. */

5. 函数调用

传值调用：函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参
传址调用：传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操 作函数外部的变量。

  1. #include<stdio.h>
  2. int isPrime(int x) {
  3.     int temp = -1;
  4.     for (int i = 2; i < x-1; i++) {
  5.         if (x % i == 0) {
  6.             temp = 1;
  7.             break;
  8.         }
  9.     }
  10.     return temp;
  11. }
  12. int main(){
  13.     int num = 12;
  14.     printf("请输入一个数字：");
  15.     scanf("%d",& num);
  16.     if (isPrime(num) == 1) {
  17.         printf("%d不是素数",num);
  18.     }
  19.     else {
  20.         printf("%d是素数",num);
  21.     }
  22.     return 0;
  23. }
  1. #include<stdio.h>
  2. int isLeapYear(int year) {
  3.     int temp = 0;
  4.     if (year % 4 == 0 && year % 100 != 0 ||year %400 == 0) {
  5.         temp = 1;
  6.     }
  7.         return temp;
  8. }
  9. int main() {
  10.     int year = 0;
  11.     printf("请输入一个年份：");
  12.     scanf("%d",&year);
  13.     if (isLeapYear(year) == 1) {
  14.         printf("%d是润年", year);
  15.     }
  16.     else {
  17.         printf("%d不是润年", year);
  18.     }
  19.     return 0;
  20. }
  1. #include<stdio.h>
  2. int binarySearch(int arr[],int num,int sz) {
  3.     int left = 0;
  4.     int right = sz - 1;
  5.     while (left<=right){
  6.         int mid = (left + right) / 2;
  7.         if (arr[mid] < num) {
  8.             left = mid + 1;
  9.         }
  10.         else if (arr[mid] > num) {
  11.             right = mid - 1;
  12.         }
  13.         else
  14.         {
  15.             return mid;
  16.         }
  17.     }
  18.     return -1;
  19. }
  20. int main() {
  21.     int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  22.     int num = 10;
  23.     int sz = (sizeof(arr) / sizeof(arr[0])) - 1;
  24.     int result = binarySearch(arr, num ,sz);
  25.     if (result == -1) {
  26.         printf("找不到指定的数字");
  27.     }
  28.     else {
  29.         printf("找到了，下标为：%d\n", result);
  31.     }
  32. }

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

嵌套调用：函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
链式访问 ：把一个函数的返回值作为另外一个函数的参数。

7. 函数的声明和定义

以后详解，未完，待续。。

8. 函数递归

什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小。
容易出现栈溢出错误（stack overflow）
1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件

  1. #include<stdio.h>
  2. void print(int x) {
  4.     printf("%d", x % 10);
  5.     if (x > 9) {
  6.         print(x / 10);
  7.     }
  9. }
  10. int main() {
  11.     int a = 1234;
  12.     print(a);
  13.     return 0;
  14. }
  1. /*编写函数不允许创建临时变量，求字符串的长度。*/
  2. #include<stdio.h>
  3. //将字符数组的地址传递过来，地址默认为第一个数的位置，所以在第一个数的基础上加1，就是第二个数字
  4. int strlen(char* str) {
  5.     if (*str != '\0') {
  6.         return 1 + strlen(str + 1);
  7.     }
  8.     else {
  9.         return 0;
  10.     }
  11. }
  12. int main() {
  13.     char ch[] = "abcdef";
  14.     int num = strlen(ch);
  15.     printf("字符串长度为：%d", num);
  16.     return 0;
  17. }