C语言初始函数模块：素数、闰年、二分查找、递归与迭代的实现
C语言初始函数模块
文章目录
- C语言初始函数模块
-
- 1. 函数是什么？
- 2. C语言中函数的分类：
-
- 2.1 库函数：
-
- 2.1.1为什么会有库函数？
- 2.1.1 如何学会使用库函数？
- 2.2 自定义函数
-
- 2.2.1 找出两个整数中的最大值
- 2.2.2 交换两个整形变量的内容
- 3. 函数的参数
-
- 3.1 实际参数（实参）：
- 3.2 形式参数（形参）：
- 4. 函数的调用：
-
- 4.1 传值调用
- 4.2 传址调用
- 4.3 练习
-
- 4.3.1 判断素数
- 4.3.2 判断闰年
- 4.3.3 实现二分查找（有序）
- 4.3.4 每调用一个函数，num 值就加1
- 5. 函数的嵌套调用和链式访问
-
- 5.1 嵌套调用
- 5.2 链式访问
- 6. 函数的声明和定义
-
- 6.1 函数声明：
- 6.2 函数定义：
-
- 6.2.1 add.h 的内容
- 6.2.2 add.c 的内容
- 6.2.3 test.c 的内容
- 对 VS2019 的补充解释：
- 7. 函数递归
-
- 7.1 什么是递归？
- 7.2 递归的两个必要条件
-
- 7.2.1 按序打印
- 7.2.2 求字符串的长度（模拟实现strlen）
- 7.3 递归与迭代
-
- 7.3.1 求n的阶乘（不考虑溢出）
- 7.3.2 求第n个斐波那契数（不考虑溢出）
1. 函数是什么？
数学中我们常见到函数的概念。但是你了解C语言中的函数吗？
维基百科中对函数的定义：子程序
在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2. C语言中函数的分类：
1.库函数
2.自定义函数
2.1 库函数：
C语言的编译器提供了一些库函数。
C语言就是语法，进行了一些规定：功能、参数、返回类型，不管如何实现，交给编译厂商实现。
编译厂商举例：
VS——微软实现
gcc——gcc官方实现
clang——苹果实现
……
如果没有C语言会出现哪些问题？
1.开发效率低
2.不够标准
3.容易出bug
- 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
- 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
- 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
2.1.1为什么会有库函数？
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
那怎么学习库函数呢？
这里我们简单的看看：www.cplusplus.com和cppreference.com(中文翻译版)
简单的总结，C语言常用的库函数都有：
- IO函数
input、output（标准输入输出函数）、getchar、putchar……
- 字符串操作函数
- 字符操作函数
- 内存操作函数
- 时间/日期函数
- 数学函数
- 其他库函数
我们参照文档，学习几个库函数：
[strcpy](strcpy - C++ Reference (cplusplus.com))
char * strcpy ( char * destination, const char * source );
#include [memset](memset - C++ Reference (cplusplus.com))
void * memset ( void * ptr, int value, size_t num );
int main()
{
char arr[] = "hello beauty!";
memset(arr, 'x', 5);
printf("%s\n", arr);
return 0;
}
注：
使用库函数，必须包含 #include 对应的头文件。
这里对照文档来学习上面几个库函数，目的是掌握库函数的使用方法.
2.1.1 如何学会使用库函数？
需要学会查询工具的使用(英文很重要,最起码得看懂文献。)：
MSDN (Microsoft Developer Network)
www.cplusplus.com
http://en.cppreference.com（英文版）
http://zh.cppreference.com（中文版）
2.2 自定义函数
如果库函数能干所有的事情，那还要程序员干什么？所有更加重要的是自定义函数。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
函数的组成：
ret_type fun_name(para1, * )
{
statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数
2.2.1 找出两个整数中的最大值
#include 2.2.2 交换两个整形变量的内容
#include 3. 函数的参数
3.1 实际参数（实参）：
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
//实参的形式：
int m=get_max(a,b);//变量
int m=get_max(a，10);//常量
int m=get_max(a,2+7);//表达式
int m=get_max(a,get_max(3,4));//函数
//……
3.2 形式参数（形参）：
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
上面 Swap1 和 Swap2 函数中的参数 x，y，px，py 都是形式参数。在main函数中传给 Swap1 的 num1 ，num2 和传给 Swap2 函数的 &num1 ， &num2 是实际参数。
这里我们对函数的实参和形参进行分析:
代码对应的内存分配如下：
这里可以看到 Swap1 函数在调用的时候， x ， y 拥有自己的空间，同时拥有了和实参一模一样的内容。
所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。
4. 函数的调用：
4.1 传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
4.2 传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
4.3 练习
4.3.1 判断素数
#include 4.3.2 判断闰年
#include 4.3.3 实现二分查找（有序）
int binary_search(int* arr, int k,int sz)
//数组传参，形参部分可以写成指针也可以写成数组，写成数组也更易理解
//int binary_search(int arr[], int k, int sz)
{
int left = 0;
int right = sz-1;
while (left<=right)
{
int mid = left + (right - left) / 2;//预防下标越界
if (arr[mid] > k)
{
right = mid - 1;
}
else if (arr[mid] < k)
{
left = mid + 1;
}
else
{
return mid;//“找到了”
}
}
return -1;//对应“找不到”的情况
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
// 实现先算出再传参的目的：因为数组传的是首元素的地址
// 在形参中写此表达式算不出数组的长度
int k = 7;
//找到了返回下标0~9
//找不到返回-1
//数组传参，传递的是首元素的地址
int ret=binary_search(arr, k,sz);
if (-1 == ret)
printf("找不到\n");
else
printf("找到了，下标是：%d\n", ret);
return 0;
}
4.3.4 每调用一个函数，num 值就加1
void Add(int*p)
{
*p=*p+1;
//*p++的写法是错误的，因为++的优先级更高，++作用于p
//但可写成（*p）++
}
int main()
{
int num = 0;
//调用函数，使得num每次增加1
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
return 0;
}
//另，不用指针的写法
int Add(int n)
{
return n+1;
}
int main()
{
int num = 0;
//调用函数，使得num每次增加1
num=Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
return 0;
}
5. 函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
5.1 嵌套调用
函数可以嵌套调用，但是不能嵌套定义。
#include 5.2 链式访问
把一个函数的返回值作为另外一个函数的参数
#include 
6. 函数的声明和定义
6.1 函数声明：
- 告诉编译器函数、参数、返回类型。函数声明决定不了具体是否存在。
- 函数的声明一般出现在函数的使用之前，要满足先声明后使用。
- 函数的声明一般要放在头文件中的。
//函数声明
int Add(int, int);
//也可写成：
int Add(int x, int y);
int main()
{
int a = 10;
int b = 20;
int s = Add(a, b);
printf("%d\n", s);
return 0;
}
int Add(int x, int y)
{
return x + y;
}
6.2 函数定义：
是指函数的具体实现，交待函数的功能实现。
实现分块写函数；实现对函数的隐藏
6.2.1 add.h 的内容
头文件中放：函数的声明，类型的定义，头文件的包含
//函数的声明
int Add(int x, int y);
6.2.2 add.c 的内容
函数的定义
int Add(int x, int y)
{
return x + y;
}
6.2.3 test.c 的内容
放置函数的实现
#include对 VS2019 的补充解释：
VS2019 是集成开发环境 IDE，是编辑器、编译器、链接器、调试器
7. 函数递归
递：递推； 归：回归
7.1 什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略。
只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小
7.2 递归的两个必要条件
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。
7.2.1 按序打印
接受一个整型值（无符号），按照顺序打印它的每一位。
无递归版本：
int main()
{
unsigned int num = 0;
scanf("%u", &num);
while (num)
{
printf("%d ", num % 10);
num = num / 10;
}
//1234
//1234%10=4
//1234/10=123
//123%10=3
//123/10=12
//12%10=2
//12/10=1
//1%10=1
//1/10=0
return 0;
}
递归版本：
//递归的思想：大事化小
//print(1234)
//print(123) 4
//print(12) 3 4
//print(1) 2 3 4
//1 2 3 4
void print(unsigned int n)
{
if (n < 10)
printf("%d ", n);
else
{
print(n / 10);
printf("%d ", n%10);
}
}
int main()
{
unsigned int num = 0;
scanf("%u", &num);
print(num);
return 0;
}
递归改进版本：
void print(unsigned int n)
{
if (n > 9)
{
print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
unsigned int num = 0;
scanf("%u", &num);
print(num);
return 0;
}
7.2.2 求字符串的长度（模拟实现strlen）
编写函数不允许创建临时变量，求字符串的长度。
运用strlen：
#include模拟实现strlen（无递归版本）：
int my_strlen(char*str)//str:指针变量：存放a的地址
{
int count = 0;
while (*str != '\0');//*解引用
{
count++;
str++;
//*str++;如a++（没有用）
}
return count;
}
int main()
{
char arr[] = "abc";
int len = my_strlen(arr);//char*
printf("%d\n", len);
return 0;
}
递归版本：
int my_strlen(char*str)//str:指针变量：存放a的地址
{
//递归方法
if (*str != '\0')
return 1 + my_strlen(str + 1);
// return 1 + my_strlen(str++);
// 错误写法：先使用，后++
// return 1 + my_strlen(++str);
// ++后原结果也变了，不建议用此写法
else
return 0;
}
int main()
{
char arr[] = "abc";
int len = my_strlen(arr);//char*
printf("%d\n", len);
return 0;
}
7.3 递归与迭代
7.3.1 求n的阶乘（不考虑溢出）
关键实现代码：
int factorial(int n)
{
if(n <= 1)
return 1;
else
return n * factorial(n-1);
}
完整代码：
//递归
int Fac1(int n)
{
if (n <= 1)
return 1;
else
return n * Fac1(n - 1);
}
//迭代（循环是迭代的一种）
int Fac2(int n)
{
int i = 0;
int ret = 1;
for (i = 1; i <= n; i++)
{
ret = ret * i;
}
return ret;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d\n", ret);
return 0;
}
7.3.2 求第n个斐波那契数（不考虑溢出）
关键实现代码：
int fib(int n)
{
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
完整代码：
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=Fib(n);
printf("%d\n", ret);
return 0;
}
发现问题：
-
在使用 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);
}
完整代码：
int count = 0;
int Fib(int n)
{
if (n == 3)
count++;
if (n <= 2)
return 1;
else
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret=Fib(n);
printf("%d\n", ret);
printf("count=%d\n", count);
return 0;
}
最后我们输出看看count，是一个很大很大的值。
因此，求Fib数列不适合用递归求解
那我们如何改进呢？
- 在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）这样的信息。
- 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
那如何解决上述的问题：
- 将递归改写成非递归。
- 使用static对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代 nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
提示：
- 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
- 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
- 当一个问题相当复杂难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。