1.函数是什么

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

1.在计算机科学中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成，它负责完成某项特定的任务，而且相较于其他代码，具备独立性

2.一般会有输入参数和返回值，提供对过程的封装和细节的隐藏，这些代码通常被集成为软件库

C语言中函数的分类

1.库函数

2.自定义函数

2.库函数

C语言把常用功能进行了封装，封装成一个个的函数，提供出来，大家都可以使用

比如：scanf 输入函数    printf 打印输出函数    strlen 求字符串长度函数    strcmp 字符串比较函数   rand   srand   time  等函数 ,像这些函数的一些功能，它们不是业务性的代码。我们在开发过程中每个程序员都可能用到，为了支持可移植性和提高编程的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。、

那么怎么学习库函数呢？我们可以去  http://www.cplusplus.com 这c++的官网,里面有c库，可以查看C语言中的所有库函数，也可以搜索函数名来查看函数的使用方法，可以为我们学习函数提供帮助。

注意：C语言并不去直接实现库函数，而是提供了C语言的标准和库函数的约定。例如scanf函数的功能，名字，参数，返回值  。库函数的实现一般是由编译器去实现的。如：VS2022  gcc

简单的总结，C语言中常用的库函数可以分为以下几类，都有

1.IO函数     输入输出函数 scanf     printf     getchar     putchar

2.字符串操作函数   strlen   strcmp   ...

3.字符操作函数     islower   isupper     判断是否为大小写

4.内存操作函数  memset   memcmp           (内存memory)

5.时间/日期函数   time

6.数学函数   sqrt 开根号     pow   次方  .....

7.其他库函数

strcpy  字符串拷贝函数

这是从c++官网上搜索strcpy函数的截图，声明是:

char * strcpy ( char * destination ,const char * source );

作用是将首地址位于source的字符串，拷贝到destination处，source处的字符串的 '\0' 也会拷贝。但destination处的字符串必须足够长，可以放得下位于source处的字符串才可以，否者会造成溢出。

对于数组，数组名其实是一个元素的地址，也就是起始地址。

大家会发现经过strcpy函数将arr1拷贝到arr2，arr2 最后打印的是 hello world。

memset  内存设置函数

声明：

void * memset (void * ptr, int value, size_t num );

作用：将 ptr 指向的内存块的前num个字节设置为指定值value。

可以发现arr1字符串中的前3个字节被替换为 '*' 。

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

3.自定义函数

如果库函数能干所有的事情，那还要程序干什么？所以有了更加重要的自定义函数。

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

函数的组成

函数返回值类型 函数名称(函数参数)
{
    语句项;
}

看下面一个例子，写一个函数可以找出两个整数的最大值

#include<stdio.h>
//int 函数返回值类型   get_max函数名称
int get_max(int x, int y)// x,y为形参  x接受num1  y接受num2
{
  return (x > y) ? x : y;//三目操作符，返回x和y中的最大值
}
int main()
{
  int num1 = 10;
  int num2 = 20;
  int max = get_max(num1, num2);//max来存放get_max函数的返回值，num1，num2为实参
  printf("%d\n", max);
  return 0;
}

4.函数的参数：

写一个函数可以交换两个整形变量的内容。

​​#include<stdio.h>
void swap1(int x, int y)
{
  int t = x;
  x = y;
  y = t;
}
void swap2(int* px, int* py)//传入的是地址，用指针变量接收  int *
{
  int t = *px;
  *px = *py;
  *py = t;
}
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函数没有交换num1和num2的值，代码有bug(缺陷），运行时错误，没有达到想要的效果。而swap2函数成功交换了num1和num2的值。这里就要引入函数的参数。

函数参数分两类

1.实际参数（实参）

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

2.形式参数（形参）

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

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

通过运行调试，&取地址，可以发现，num1与x,  num2与y,存放的地址是不同的，使用的不是同一块空间，x和y拥有自己的空间，同时拥有了和实参一摸一样的内容，所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝，所以对形参的修改不会形象实参。

5.函数的调用：

1.传值调用 swap1 函数

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

2.传址调用  swap2 函数

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

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

swap2函数传入的时变量num1,num2的地址，所以通过形参的指针就能够访问到函数外部的变量。并对num1,num2进行操作

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

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

嵌套调用  

函数内部再调用函数，可以是自身，也可是其他函数

//函数可以嵌套调用
//但是不能嵌套定义
//每个函数都是独立的
#include<stdio.h>
void print_line()//定义print_line函数
{
  printf("hehe\n");
}
void three_line()//定义three_line函数
{
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    print_line();//一个函数内部可以调用其他的函数
  }
}
int main()//定义main函数，程序的入口
{
  three_line();
  return 0;
}

链式访问

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

//链式访问
//把一个函数的返回值，作为另外一个函数的参数
#include<string.h>//strlen函数
#include<stdio.h>
int main()
{
  //1.
  /*int len = strlen("abcdef");
  printf("%d\n", len);*/
  //2.把strlen函数的返回值作为printf函数的参数，就是链式访问
  printf("%d\n", strlen("abcdef"));
  return 0;
}

可以看一下下面代码

printf函数的返回值是打印字符的个数，最里面的 printf 先执行。

#include<stdio.h>
int main()
{
  //printf函数返回值是打印字符的个数
  // 最里面printf函数先打印，顺序有里向外
  //       1           2            43
  printf("%d", printf("%d", printf("%d", 43)));//打印4321
  printf("\n");
  //空格也是字符,printf函数返回值加一
  printf("%d ", printf("%d ", printf("%d ", 43)));//打印43 3 2
  return 0;
}

7.函数的声明和定义

函数声明：

1.告诉编译器有一个函数叫什么，参数是什么，返回值类型是什么。但是具体是不是存在，无关紧要。

2.函数的声明一般出现在函数的使用之前，要满足先声明后使用。

3.函数的声明一般要放在头文件中的

函数的定义

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

//函数声明和定义
//编译器在编译代码时，都是从上开始扫描
//函数在使用(调用)时必须先声明
#include<stdio.h>
//函数的声明
int Add(int x, int y);
//int Add(int, int);//声明时形参名字可以不写，因为这里不使用，只是声明
//函数的定义是一种特殊的声明，把定义放到调用上面可以不用再次声明  
int main()
{
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int c = Add(a, b);//函数的调用
  printf("%d\n", c);
  return 0;
}
//函数的定义   
int Add(int x, int y)
{
  return x + y;
}

函数的声明和定义其实通常不是这样使用的

函数的声明是放在头文件中的  .h

定义放在一个.c文件中

分三个文件， add.h 声明Add函数   add.c  定义Add函数    test.c中调用Add函数

这样写是因为在公司写代码，是需要协作的

1.分模块去写，方便协作，最后做整合

2.可以把代码的实现和声明分离

8.函数的递归

什么是递归

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

递归的两个必要条件

1.存在一个限制条件，当满足这个限制条件的时候，递归便不再继续。

2.每次递归调用之后越来越接近这个限制条件

递归例题

练习1：接受一个整形值，按照顺序打印它的每一位。例如：输入 ：1234  打印 1 2 3 4

#include<stdio.h>
void print(unsigned int n)
{
  /*int x = n % 10;
  int n1 = n / 10;
  if (n1 >= 1)
  {
    print(n1);
  }
  printf("%d ", x);*/
  if (n > 9)//递归限制条件
  {
    print(n / 10);//每次递归调用之后越来越接近这个限制条件
  }
  printf("%d ", n%10);
}
int main()
{
  unsigned int num = 0;
  scanf(" %d", &num);
  print(num);
  return 0;
}

图解：

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

#include<stdio.h>
//非递归
int my_strlen(char* s)
{
  int count = 0;
  while (*s != '\0')
  {
    count++;
    s++;
  }
  return count;
}
//递归
int my_strlen(char* s)
{
  if (*s != '\0')
  {
    return 1 + my_strlen(s+1);
  }
  else
    return 0;
}
int main()
{
  char arr[] = "abcd";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

递归与迭代

练习3：求n的阶乘（不考虑溢出）

//循环（迭代）
#include<stdio.h>
int Fac(int n)
{
  int i = 0;
  int sum = 1;
  for (i = 1; i <= n; i++)
  {
    sum *= i;
  }
  return sum;
}
//递归实现
int factorial(int n)
{
  if (n <= 1)
    return 1;
  else
  {
    return n * factorial(n - 1);
  }
}
int main()
{
  int n = 0;
  scanf("%d", &n);
  int ret = Fac(n);
  printf("%d\n", ret);
  return 0;
}

练习4：求第n个斐波那契数列

//求第n个斐波那契数
//迭代
#include<stdio.h>
int test(int n)
{
  int a = 1;
  int b = 1;
  int c = 1;
  while (n >= 3)
  {
    c = a + b;
    a = b;
    b = c;
    n--;
  }
  return c;
}
//递归
int fib(int n)
{
  if (n <= 2)
    return 1;
  else
    return fib(n - 1) + fib(n - 2);
}
int main()
{
  int n = 0;
  scanf("%d", &n);
  int ret = test1(n);
  printf("%d\n", ret);
  return 0;
}

但是我们发现有问题

1.在使用fib这个函数的时候如果我们要计算第50个斐波那契数列数字的时后特别耗时间。

2.使用factorial函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

我们发现fib函数在调用的过程中很多计算其实在一直重复，求50时要求49和48，49又要求48，47，48求47，46，要求大约2的50次方次，非常多。如果我们把代码修改一下

int count = 0;//全局变量
int fib(int n)
{
    if(n == 3)
        count++;
  if (n <= 2)
    return 1;
  else
    return fib(n - 1) + fib(n - 2);
}

最后求一下第40个斐波那契数，我们输出可以看到count是一个很大很大的值。

那我我们应该如何改进呢？

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

那么如何解决上述的问题：

1.将递归改写为非递归。

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

提示：

1.许多问题是以递归的形式进行解释的，这是因为它比非递归的形式更清晰

2.但是这些问题的迭代实现往往比递归的实现效率更高，虽然代码可读性稍微差些。

3.当一个问题相当复杂，那一用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。