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

函数的嵌套调用

函数是不能嵌套定义的

void test1()
{
  void test2()
  {
  }
}
int main()
{
  return 0;
}

但是函数可以嵌套调用

void test2()
{
  printf("hehe\n");
}
int test1()
{
  test2()
  return 0;
}
int main()
{
  //在main函数里调用了test1，在test1函数里调用了test2 
  test1();
  return 0;
}

函数的链式访问

#include<stdio.h>
#include<string.h>
int main()
{
  int len = strlen("abc");
  printf("%d\n", len);
  //这里strlen的返回值就做了printf的参数->这就叫链式访问
  printf("%d\n", strlen("abc"));
  //---------------------------------------------------------
  char arr1 [20] = {0};
  char arr2 [] = "bit";
  strcpy(arr1, arr2);
  printf("%s\n", arr1);
  //这里strcpy的返回值(arr1的地址),就做了printf的参数
  printf("%s\n", strcpy(arr1,arr2));
  return 0;
}

看代码，输出结果是多少

#include<stdio.h>
int main()
{
  printf("%d", printf("%d", printf("%d", 43)));//4321
  //printf的返回值是打印在屏幕上的字符的个数
  //第1次打印43 -> 返回值是2 -> 2作为第2次打印的参数，返回值是1 -> 1作为第3次打印的参数
  return 0;
}

六、函数的声明和定义

函数声明
1.告诉编译器有一个函数叫什么，参数是什么(参数名可加可不加)，返回类型是什么。但是具体是否存在，无关紧要
2.函数的声明一般出现在函数的使用之前。要满足先声明后使用
3.函数的声明一般要放在头文件中
函数定义
1.函数的定义是指函数的具体实现，交待函数的功能实现
如果函数定义在main函数后面，需要先声明；如果函数定义在main函数之前，则不用声明

在main函数里使用定义在main函数后面的函数

warning:Add未定义

解决方法:声明

#include<stdio.h>
int main()
{
  int a = 10;
  int b = 20;
  //函数的声明 - extern可加可不加
  extern int Add(int, int);
  int c = Add(a,b);
  printf("%d\n", c);
  return 0;
}
//函数的定义
int Add(int x, int y)
{
  return x + y;
}

但其实在以后的编码中这种写法是很少见的；具体场景看以下代码：

写一个计算器

七、函数递归

1. 什么是递归

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

2. 递归的三个必要条件

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

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

3.递归的层次不能太深(补充)

这是一个错误的递归，因为它缺少递归的两个必要条件。但是它确实是自己调用了自己

#include<stdio.h>
int main()
{
  printf("hehe\n");
  main();
  return 0;
}

运行现象：死循环？ - NO~ 发现在运行时,过了会它停下来了

经调试发现 -> Stack overflow:栈溢出

这里有一个程序猿的知乎网站

https://stackoverflow.com/

3.通过练习了解递归

1.接收一个整形值(无符号)，按照顺序打印它的每一位。如：1234，输出1 2 3 4

1：

逆序输出：

1234 / 10^0 % 10 = 4

1234 / 10^1 % 10 = 3

1234 / 10^2 % 10 = 2

1234 / 10^3 % 10 = 1

-----------------------------------------------------------------

顺序输出：

1234 / 10^3 % 10 = 1

1234 / 10^2 % 10 = 2

1234 / 10^1 % 10 = 3

1234 / 10^0 % 10 = 4

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
int main()
{
  unsigned int num = 0;//存放输入的数
  scanf("%u", &num);
  int temp = num;//拷贝这个数
  int count = 0;//计算这个数有几位
  //判断输入的数有几位
  while(temp)
  {
    temp /= 10;
    count ++;
  }
  //顺序求每位数
  int i = 0;
  for(i = count - 1; i >= 0; i--)
  {
    //int ret = pow(10,i);
    //printf("%d ", num / ret % 10);//1 2 3 4
    printf("%d ", num / (int)pow(10, i) % 10);//pow这个函数的返回值和参数类型都是double类型
  }
  return 0; 
}

2：

使用递归的方式

print(1234)

print(123) 4

print(12) 3 4

print(1) 2 3 4

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void print(unsigned int n)
{
  //如果是2位数及以上，就要拆分; 
  //满足递归的2个必要条件
  if (n > 9)
  {
    print(n / 10);
  }
  printf("%d ", n % 10);
}
int main()
{
  unsigned int num = 0;
  scanf("%u", &num);
  //递归 - 函数自己调用自己 - print函数可以打印参数部分数字的每一位
  print(num); 
  return 0;
}

这种代码对于初学者不是很友好，但却是程序设计中一个很重要的点，所以看剖析图：

上面说递归有2个必要条件，那么有这2个条件，递归就一定对吗？看代码：

void test(int n)
{
  if(n < 10000)//限制条件
  {
    test(n + 1);//且每次越来越接近这个限制条件
  }
}
int main()
{
  test(1);
  return 0;
}

经逐过程调试：又遇到了Stack overflow -> 栈溢出

要了解什么是栈溢出，就要了解内存

虽然有2个必要条件，显然这里是栈空间不足，才导致的栈溢出。

没有这2个必要条件一定错，但是同时有也不一定对，所以在上面又补充了1个条件：递归的层次不能太深

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

在之前有提到在求字符串长度时有1个库函数strlen

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "bit";
  printf("%d\n", strlen(arr));//3
  return 0;
}

模拟实现strlen函数

#include<stdio.h>
int my_strlen(char* str)
{
  int count = 0;//统计字符
  while(*str != '\0')
  {
    count++;
    str++;
  }
  return count;
}
int main()
{
  char arr[] = "bit";
  printf("%d\n", my_strlen(arr));
  return 0;
}

递归思想：

my_strlen (“bit”)

1 + my_strlen (“it”);

1 + 1 + my_strlen (“t”);

1 + 1 + 1 + my_strlen ("");

1 + 1 + 1 + 0 = 3;

#include<stdio.h>
int my_strlen(char* str)
{
  if (*str)//限制条件
    return 1 + my_strlen(str + 1);//且每次递归 越来越接近于这个限制条件
    //return 1 + my_strlen(str++);//err；str++和++str这2种写法是错误的，在递归中也不建议这样写
  else
    return 0;//注意这里return 0是必需有的，因为在最后条件不满足时，递归结束，程序回收，返回到上1级的递归时 -> return 1 + my_strlen(str + 1)，这里的值是未知的
    //所在在写递归时我们不仅要考虑到递归的3个条件，还要在回收递归时多加考虑
}
int main()
{
  char arr[] = "bit";
  printf("%d\n", my_strlen(arr));
  return 0;
}

为了方面理解，又画了一个剖析图

八、递归与迭代

1.求n的阶乘(不考虑溢出)

1.循环也可以被称为迭代

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
  int n = 0;
  scanf("%d", &n);
  int i = 0;
  int ret = 1;
  //迭代
  for(i = 1; i <= n; i++)
  {
    ret *= i;
  } 
  printf("%d\n", ret);
  return 0; 
}

2.递归

公式：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Fac(int n)
{
  if (n > 1)
    return n * Fac(n - 1);
  else
    return 1;
}
int main()
{
  int n = 0 ;
  scanf("%d", &n);
  int ret = Fac(n);
  printf("%d\n", ret);
  return 0;
}

2.求第n个斐波那契数(不考虑溢出)

1 ，1，2，3，5，8，13，21，34，55 …

斐波那契数列就是前2个数之和等于第3个数

公式：

1：递归

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Fib(int n)
{
  if(n > 2)
    return Fib(n - 1) + Fib(n - 2);
  else
    return 1;
}
int main()
{
  int n = 0;
  scanf("%d", &n);
  int ret = Fib(n);
  printf("第%d个斐波那契数是%d\n", n, ret);
  return 0;
}

这里当我们想计算出第50位的斐波那契数的时候。算了我等了许久也没等出来(大概需要5-10分钟左右),难道计算机偷懒了吗？所以这里计算44，方便能观察结果。

为了证明计算机没有偷懒

这里我们看一下在计算第40个斐波那契数时需要计算多少次第3个斐波那契数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int count = 0;
int Fib(int n)
{
  //统计第3个斐波那契数的计算次数
  if(3 == n)
    count++;
  if(n > 2)
    return Fib(n - 1) + Fib(n - 2);
  else
    return 1;
}
int main()
{
  int n = 0;
  scanf("%d", &n);
  int ret = Fib(n);
  printf("第%d个斐波那契数是%d\n", n, ret);
  printf("在计算第40个斐波那契数时，第3个斐波那契数需要被计算%d次\n", count);
  return 0;
}

显然不是计算机偷懒，而是代码效率太低 - 重复大量的计算

可见，只要栈不溢出，递归都可以求解，但是效率太低

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Fib(int n)
{
  if(n > 2)
    return Fib(n - 1) + Fib(n - 2);
  else
    return 1;
}
int main()
{
  int n = 0;
  scanf("%d", &n);
  int ret = Fib(n);
  printf("第%d个斐波那契数是%d\n", n, ret);
  return 0;
}

2：优化 - 使用循环的方式

前面使用递归求斐波那契数时，是从后往前的，它要一层层的展开，导致重复计算；如果从前往后的不断累加上去，相比效率就要高的多。

具体思路：如果是第2个斐波那契数以下的直接打印；如果是第2个斐波那契数以上的：先拷贝前2个斐波那契数f1、f2，在求第n个斐波那契数时，不断让f1和f2累计运算，得到后面1个数的值，直到第n位斐波那契数

for循环版本：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
  int i = 0;
  int f1 = 1;
  int f2 = 1;
  int n = 0;
  scanf("%d", &n);
  if (n < 3)
    printf("第%d个斐波那契数是%d\n", n, f1);
  else
  {
      for(i = 3; i <= n; i++)
      {
        f2 = f1 + f2;
        f1 = f2 - f1;
      }
      printf("第%d个斐波那契数是%d\n", n, f2);
  }
}

while循环版本：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
  int f1 = 1;
  int f2 = 1;
  int f3 = 1;//将结果设置为1，在求<3的斐波那契数时直接输出1
  int n = 0;
  scanf("%d", &n);
  int u  = n;//拷贝1份，因为在while循环里要改变n的值，不方便在下面的输出
  while(u > 2)
  {
    f3 = f1 + f2;
    f1 = f2;
    f2 = f3;
    u--;
  }
  printf("第%d个斐波那契数是%d\n", n, f3);
  return 0;
}

接着我们想来看一下循环版本第50位斐波那契数是多少？

效率非常快，但是显然这个数已经已经不能被int类型所存储了。

最后在这里想说的是递归并不一定适于所有代码，使用递归可能会写出栈溢出、和效率低等问题。所以在以后的编码中，要知道哪种方法更适用。

C语言 - 函数下

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

六、函数的声明和定义

七、函数递归

1. 什么是递归

2. 递归的三个必要条件

3.通过练习了解递归

1.接收一个整形值(无符号)，按照顺序打印它的每一位。如：1234，输出1 2 3 4

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

八、递归与迭代

1.求n的阶乘(不考虑溢出)

2.求第n个斐波那契数(不考虑溢出)

热门文章

最新文章

相关课程

相关电子书

C语言 - 函数 下

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

六、函数的声明和定义

七、函数递归

1. 什么是递归

2. 递归的三个必要条件

3.通过练习了解递归

1.接收一个整形值(无符号)，按照顺序打印它的每一位。如：1234，输出1 2 3 4

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

八、递归与迭代

1.求n的阶乘(不考虑溢出)

2.求第n个斐波那契数(不考虑溢出)

热门文章

最新文章

相关课程

相关电子书

C语言 - 函数下