函数
- 1.什么是函数
- 2.C语言中函数的分类
- 2.1 库函数
- 2.1.1如何使用库函数
- 2.2自定义函数
- 3.函数的参数
- 3.1实际参数（实参）
- 3.2形式参数（形参）
- 4.函数的调用
- 4.1 传值调用
- 4.2 传址调用
- 4.3 练习
- 5.函数的嵌套使用和链式访问
- 5.1 嵌套调用
- 5.2 链式访问
- 6. 函数的声明与定义
- 6.1 函数声明
- 6.2 函数定义
- 7.函数递归
- 7.1 什么是递归
- 7.2 递归的两个必要条件
- 7.2.1 练习1
- 7.2.2 练习2
- 7.3 递归与迭代
- 7.3.1 练习3
- 7.3.2 练习4
1.什么是函数
数学中我们常见到函数的概念。但是你了解C语言中的函数吗？
维基百科中对函数的定义：子程序
- 在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。
- 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2.C语言中函数的分类
- 库函数
- 自定义函数
2.1 库函数
为什么会有库函数？
- 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想
把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格
式打印到屏幕上（printf）。- 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
- 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，
为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员
进行软件开发。
库函数是由C语言提供的么？
C语言标准中约定好，由编译器厂商提供实现
C语言标准规定：
- 函数功能—测字符串长度
- 函数名 strlen
- 参数 const char* str
- 返回类型 size_t
那怎么学习库函数呢？
这里我们简单的看看：www.cplusplus.com
简单的总结，C语言常用的库函数都有：
- IO函数
- 字符串操作函数
- 字符操作函数
- 内存操作函数
- 时间/日期函数
- 数字函数
- 其他库函数
学习几个库函数：
strcpy：
代码案例：
int main()
{
char arr1[20] = "xxxxxxxxxxxx";
//
char arr2[] = "hello C";
printf("%s\n", strcpy(arr1, arr2));
return 0;
}
运行结果：
memset：
代码案例：
int main()
{
char arr[] = "hello C";
memset(arr, 'c', 5);
printf("%s\n", arr);
return 0;
}
运行结果：
注：
但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。
这里对照文档来学习上面几个库函数，目的是掌握库函数的使用方法。
2.1.1如何使用库函数
需要全部记住吗？No
需要学会查询工具的使用：
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 – 函数参数
我们举一个例子：
写一个函数可以找出两个整数中的最大值。
代码演示：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int get_max(int x, int y)
{
//函数体
if (x > y)
return x;
else
return y;
}
int main()
{
int num1 = 0;
int num2 = 0;
scanf("%d %d", &num1, &num2);
printf("%d\n", get_max(num1, num2));
return 0;
}
运行结果：
根据实际需求选择写不写参数（如下不需写参数）
void print()
{
printf("hehe\n");
}
再举一个例子：
写一个函数可以交换两个整形变量的内容
//实现成函数，但是不能完成任务
//形式参数
void Swap1(int x, int y)
{
int z = 0;
z = x;
x = y;
y = z;
}
int main()
{
int num1 = 0;
int num2 = 0;
scanf("%d %d", &num1, &num2);
printf("交换前：num1 = %d num2 = %d\n", num1, num2);
//实际参数
Swap1(num1, num2);
//函数调用的时候，将实参传递给形参
//形参其实是实参的一份临时拷贝
//对形参的修改，不会改变实参
printf("交换后：num1 = %d num2 = %d\n", num1, num2);
return 0;
}
运行结果:
为什么没用进行交换? 让我们来看看下面这段代码:
//正确的版本
//形式参数
void Swap2(int* p1, int* p2)
{
int tmp = 0;
tmp = *p1;//tmp = num1;
*p1 = *p2;//num1 = num2;
*p2 = tmp;//num2 = tmp;
}
int main()
{
int num1 = 0;
int num2 = 0;
scanf("%d %d", &num1, &num2);
printf("交换前：num1 = %d num2 = %d\n", num1, num2);
//实际参数
Swap2(&num1, &num2);
printf("交换后：num1 = %d num2 = %d\n", num1, num2);
return 0;
}
运行结果:
案例分析图：
3.函数的参数
3.1实际参数（实参）
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
3.2形式参数（形参）
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。
形式参数当函数调用完成之后就自动销毁了，因此形式参数只在函数中有效。
这里可以看到 Swap1 函数在调用的时候， x ， y 拥有自己的空间，同时拥有了和实参一模一样的内容。
所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。
4.函数的调用
4.1 传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
4.2 传址调用
- 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
4.3 练习
- 写一个函数可以判断一个数是不是素数
bool is_prime(int n)
{
int j = 0;
for (j = 2; j <= sqrt(n); j++)
{
if (n % j == 0)
return false;
}
return true;
}
int main()
{
int i = 0;
int count = 0;
for (i = 101; i <= 200; i += 2)//素数不可能是奇数
{
if (is_prime(i))
{
count++;
printf("%d ", i);
}
}
printf("\ncount=%d\n", count);
return 0;
}
运行结果：
- 写一个函数判断一年是不是闰年
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdbool.h>
//is_run_year 不推荐的
bool is_leap_year(int y)
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
return true;
else
return false;
}
int main()
{
int y = 0;
int count = 0;
for (y = 1000; y <= 2000; y++)
{
//判断y是否是闰年
if (is_leap_year(y))
{
count++;
printf("%d ", y);
}
}
printf("\ncount = %d\n", count);
return 0;
}
运行结果：
- 写一个函数，实现一个整型有序数组的二分查找
//找到了，就返回下标
//找不到，返回 -1
int binary_search(int arr[], int k, int sz)
{
int left = 0;
int right = sz - 1;
while (left<=right)
{
//int mid = (left + right) / 2;
int mid = left + (right - left) / 2;//*******
if (arr[mid] < k)
{
left = mid + 1;
}
else if (arr[mid] > k)
{
right = mid - 1;
}
else
{
return mid;
}
}
return -1;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int k = 0;
scanf("%d", &k);//输入的是要查找的值
//FindNum();
int sz = sizeof(arr) / sizeof(arr[0]);
int ret = binary_search(arr, k, sz);
if (ret == -1)
{
printf("找不到\n");
}
else
{
printf("找到了，下标是：%d\n", ret);
}
return 0;
}
运行结果：
- 写一个函数，每调用一次这个函数，就将num的值增加1
1.
void Add(int* p)
{
*p = *p + 1;
}
int main()
{
int num = 0;
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
return 0;
}
2.
int Add(int n)
{
return n + 1;
}
int main()
{
int num = 0;
num = Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
return 0;
}
注:传值和传址利用时机
- 当你想要对传递进函数的实参经过函数内的操作发生改变，那么就用传址调用。
- 如果不对实参作出任何改变，那么就用传值调用。
5.函数的嵌套使用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
5.1 嵌套调用
#include <stdio.h>
void new_line()
{
printf("hehe\n");
}
void three_line()
{
int i = 0;
for(i=0; i<3; i++)
{
new_line();
}
}
int main()
{
three_line();
return 0;
}
函数可以嵌套调用，但是不能嵌套定义。
5.2 链式访问
把一个函数的返回值作为另外一个函数的参数。
int main()
{
char arr1[20] = {0};//abc\0.....
char arr2[] = "abc";
printf("%d\n", strlen(strcpy(arr1, arr2)));//链式访问
return 0;
}
案例：
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
//结果是啥？
//注：printf函数的返回值是打印在屏幕上字符的个数
return 0;
}
运行结果：
6. 函数的声明与定义
6.1 函数声明
- 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数
声明决定不了。- 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
- 函数的声明一般要放在头文件中的。
6.2 函数定义
函数的定义是指函数的具体实现，交待函数的功能实现。
案例一：
案例二：
未来在工程中，代码是比较多的，函数一般放在.h文件中声明 .c文件中实现的！
案例三：
为什么要将代码拆成.c .h 文件呢？
- 多人协作
- 代码保护
7.函数递归
7.1 什么是递归
程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归策略
只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小
最简单一个递归案例：
int main()
{
printf("hehe\n");
main();
return 0;
}
运行结果：
出现栈溢出现象
7.2 递归的两个必要条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
- 每次递归调用之后越来越接近这个限制条件。
7.2.1 练习1
接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234，输出 1 2 3 4.
代码演示：
void Print(int n)
{
if (n > 9)
{
Print(n/10);
}
printf("%d ", n % 10);
}
int main()
{
int num = 0;
scanf("%d", &num);//1234
//Print能将参数的num的每一位打印在屏幕上
Print(num);
//Print(1234)
//Print(123) + 4
//Print(12) + 3
//Print(1) +2
//1
return 0;
}
运行结果·：
函数之所以能实现调用，递归
都是因为，函数在调用的时候都会维护一个函数栈帧（内存上的一块区域）
函数调用开始，栈帧创建，函数调用结束，栈帧销毁
7.2.2 练习2
编写函数不允许创建临时变量，求字符串的长度。
代码演示：
#include <string.h>
//size_t 是一种类型，是无符号整型的
//size_t就是为sizeof设计的
//size_t 类型的数据打印的时候使用%zd
size_t my_strlen(char* str)
{
if (*str == '\0')
return 0;
else
return 1 + my_strlen(str+1);
}
int main()
{
char arr[] = "abc";
size_t len = my_strlen(arr);//传递的是数组首元素的地址
printf("%zd\n", len);
return 0;
}
运行结果：
7.3 递归与迭代
7.3.1 练习3
求n的阶乘。（不考虑溢出）
代码演示:
int Fac(int n)
{
if (n <= 1)
return 1;
else
return n* Fac(n - 1);
}
int main()
{
int n = 0;
scanf("%d", &n);
int r = Fac(n);
printf("%d\n", r);
return 0;
}
运行结果:
7.3.2 练习4
求第n个斐波那契数。（不考虑溢出）
代码演示:
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);//20
int ret = Fib(n);
printf("%d\n", ret);
return 0;
}
运行结果:
但是我们发现有问题；
- 在使用 Fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
- 使用 Fac 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
为什么呢？
- 我们发现 Fib 函数在调用的过程中很多计算其实在一直重复。
那我们如何改进呢？
- 在调试 Fac 函数的时候，如果你的参数比较大，那就会报错： **stack overflow（栈溢出）**这样的信息。
- 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
那如何解决上述的问题：
- 将递归改写成非递归。
- 使用static对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
比如，下面代码就采用了，非递归的方式来实现
求n的阶乘
int Fac(int n)
{
int i = 0;
int r = 1;
for (i = 1; i <= n; i++)
{
r = r * i;
}
return r;
}
求第n个斐波那契数
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while (n >= 3)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
注:何时使用递归:
如果使用递归很容易想到,写出的代码没有明显的缺陷,那我们就可以使用递归
但如果写出的递归代码,有明显问题,比如:栈溢出,效率低下等,那我们还是使用迭代的方式来解决.
本次内容来到了尾声，相信阅读本次内容的你收获满满。期待下次文章与大家见面！！！
