【深入理解递归、了解命令行参数】
本章重点
1、了解命令行参数
2、深入理解递归
什么是命令行参数呢？
C语言的命令行参数是指在程序运行时，通过命令行传递给程序的额外信息。当我们在终端或命令提示符中执行一个C语言程序时，可以在程序名后面添加参数，这些参数将被传递给程序并在程序内部使用。
在C语言中，命令行参数主要通过
main函数的参数来接收。main函数也是一个函数，其实也可以携带参数的，标准的main函数定义如下：
main函数的参数包括argc和argv，分别表示命令行参数的数量和参数字符串数组。
argc（argument count）是一个整数，表示命令行参数的数量，包括程序名称本身。至少会有一个参数，即程序的名称。argv（argument vector）是一个指向指针的数组，每个指针指向一个以空字符结尾的字符串，表示一个命令行参数。例如，执行以下命令行：
在程序内部，
argc的值将是3，argv数组将包含3个字符串指针：
argv[0]指向字符串"./myprogram"，表示程序的名称。argv[1]指向字符串"arg1"，表示第一个命令行参数。argv[2]指向字符串"arg2"，表示第二个命令行参数。通过访问
argc和argv，程序可以根据命令行参数的数量和内容，进行相应的逻辑处理。常见的用法包括：
- 读取命令行参数的值，可以使用
argv数组的索引来访问特定位置的参数字符串。- 对命令行参数进行解析和处理，例如将字符串转换为数字、进行条件判断等。
- 根据命令行参数的值来执行不同的程序逻辑，例如根据参数选择不同的操作或配置。
总之，命令行参数为C语言程序提供了一种从外部传递信息的方式，使得程序在运行时可以根据不同的参数执行不同的操作。
#include
int main(char argc, char* argv[])
{
int i = 0;
for (i = 0; i < argc; i++)
{
printf("%s", argv[i]);
}
} 运行结果
注意：argv数组的最后一个元素存放了一个 NULL 的指针。
vs如何带命令行参数呢？
运行结果
这样我们就给程序带上了命令行参数。其实呢，main函数是有三个参数的，只不过第三个参数通常不写。
第一个参数： argc 是个整型变量，表示命令行参数的个数（含第一个参数）。
第二个参数： argv 是个字符指针的数组，每个元素是一个字符指针，指向一个字符串。这些字符串就是命令行中的每一个参数（字符串）。
第三个参数： envp 是个字符指针的数组，数组的每一个元素是一个指向一个环境变量（字符串）的字符指针
了解：第三个参数本质其实是获取系统相关环境变量内容，下面的程序就可以输出相关的环境变量。
#include
int main(int argc, char* argv[], char* envp[])
{
int i = 0;
while (envp[i] != NULL)
{
printf("%s\n", envp[i]);
i++;
}
return 0;
} 深入理解递归
基本认识
- 递归本质也是函数调用，
- 函数调用本质就要形成和释放栈帧
- 根据栈帧的学习，调用函数是有成本的，这个成本就体现在形成和释放栈帧上：时间+空间
- 所以，递归就是不断形成栈帧的过程
理论认识
- 内存和CPU的资源是有限的，也就决定了，合理的递归是绝对不能无限递归下去,合法递归一定是有次数限制的
- 递归不是什么时候都能用，而是要满足自身的应用场景 即：目标问题的子问题，也可以采用相同的算法解决，本质就是分治的思想
- 核心思想：大事化小+递归出口
demo1：不使用临时变量，求字符串长度
#include
/*
abcd1234
1+bcd1234
1+1+cd1234
...
*/
int my_strlen(const char* arr)
{
if (!*arr)
return 0;//递归出口
else
return 1 + my_strlen(arr + 1);//大事化小
}
int main()
{
char arr[] = "abcd1234";
printf("%d\n", my_strlen(arr));
return 0;
} 完善程序
#include
#include
int my_strlen(const char* s)
{
assert(s != NULL);
return *s ? (MyStrlen(++s) + 1) : 0;
}
int main()
{
const char* str = "abcd1234";
int len = my_strlen(str);
printf("len: %d\n", len);
return 0;
} 功能上，代码增加了一个断言，用于确保传入
my_strlen函数的指针不为空。断言是一种在代码中放置的检查，用于在运行时验证某个条件是否为真。在这里，assert(s)用于验证传入的指针s不为空（即不能为NULL）。如果断言条件为假，程序会终止，并输出错误信息。这样可以帮助在调试时快速发现可能出现的问题。
同归斐波那契数列，来看递归调用的成本问题
摘自百科
斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、 34、……在数学上，斐波那契数列以如下被以递推的方法定义：
F(0)=0，
F(1)=1,
F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）
demo1：初步感受一下计算fib(42)结果出来的所需时间
#include
int Fib(int n)
{
if (1 == n || 2 == n) {
return 1;
}
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 42;
int x = Fib(n);
printf("Fib(%d): %d\n", n, x);
return 0;
} 通过上面的代码做实验我们发现，fib递归版在个数超过几十(我们这里是42)的时候，就已经相当慢了。
demo2：递归计算fib(42)需要多少时间
#include
#include
//包含该头文件，才能使用win提供的GetTickCount()函数，\
来获取开机到现在的累计时间,此处用它，是因为简单
int Fib(int n)
{
if (1 == n || 2 == n) {
return 1;
}
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 42;
double start = GetTickCount();
int x = Fib(n);
double end = GetTickCount();
printf("Fib(%d): %d\n", n, x);
printf("%lf s\n", (end - start) / 1000);
return 0;
} 运行结果
现在我们画图示意一下fib(6)需要算什么？
fib(7)呢？
- 如果数字再大，就非常非常慢
- 为何会这么慢呢？根本原因是因为大量的重复计算
demo3：统计一下n=3的时候，被重复计算了多少次
#include
#include
int count = 0;
int Fib(int n)
{
if (1 == n || 2 == n) {
return 1;
}
if (n == 3) {
count++; //不影响运算逻辑，就单纯想统计一下n=3的时候，被重复计算了多少次
}
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 42;
double start = GetTickCount();
int x = Fib(n);
double end = GetTickCount();
printf("fib(%d): %d\n", n, x);
printf("%lf s\n", (end - start) / 1000);
printf("count = %d\n", count);
return 0;
} 运行结果：
为何会这样？？重复计算，意味着重复调用，重复调用意味着重复形成栈帧，创建与释放栈帧，是有成本的。
demo4：如何解决？----- 迭代
#include
#include
int Fib(int n)
{
int* dp = (int*)malloc(sizeof(int) * (n + 1)); //暂时不做返回值判定了
//[0]不用(当然，也可以用，不过这里我们从1，1开始，为了后续方便)
if (dp == NULL)
return -1;
dp[1] = 1;//第一个数
dp[2] = 1;//第二个数
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
int ret = dp[n];
free(dp);
return ret;
}
int main()
{
int n = 42;
double start = GetTickCount();
int x = Fib(n);
double end = GetTickCount();
printf("fib(%d): %d\n", n, x);
printf("%lf ms\n", (end - start) / 1000);
return 0;
} 运行结果：
运行所需时间接近0.0s，只形成一次函数栈帧，消耗的成本非常低。这其实是一种动态规划的算法哦，看起来很神秘，其实这些问题也可以使用改方法解决哦。
demo5：上面的程序保存了每一个fib()的值，是通过空间消耗来节省时间，那我们还能更进一步吗？经过发现，任何一个数字，只和前两个数据相关
#include
#include
int Fib(int n)
{
int first = 1;
int second = 1;
int third = 1;
while (n > 2) {
third = second + first;
first = second;
second = third;
n--;
}
return third;
}
int main()
{
int n = 42;
double start = GetTickCount();
int x = Fib(n);
double end = GetTickCount();
printf("fib(%d): %d\n", n, x);
printf("%lf s\n", (end - start) / 1000);
return 0;
}
运行结果：
这种方法就是一种典型的迭代方法，空间和时间上消耗的成本都非常低。