[C语言基础]3.函数学习

库函数

#include C library Reference
使用库函数需要引入头文案

• <stdio.h>是 C 语言的标准输入输出头文件（“stdio” 是 “standard input & output” 的缩写）。它包含了用于输入scanf("%d", &num);和输出printf("%d", num);操作的函数声明、宏定义和类型定义，这些功能是 C 语言程序与外部设备（如键盘、显示器等）进行数据交互的基础。

自定义函数

eg1.写一个函数可以找出两个整数中的最大值

//get_max函数的设计  
int get_max(int x, int y)  
{  
	return (x>y)?(x):(y);  
}  
int main()  
{  
	int num1 = 10;  
	int num2 = 20;  
	int max = get_max(num1, num2);  
	printf("max = %d\n", max);
	return 0;  
}

(x>y)?(x):(y);
三目操作符1.C语言初识### 条件操作符__三目操作符 exp__表达式

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

void Swap(int *pa,int *pb)//void表示不需要返回
//因为函数内部已经通过指针直接对main函数中的变量进行了修改
//所以不需要通过返回值来传递交换后的结果。
//当Swap函数执行完毕后，main函数中的a和b变量的值已经被交换。
{
	int z = 0;
	z = *pa;//*pa是&a，指针是地址
	*pa = *pb;//*pb是&b
	*pb = z;
}
int main()
{
	int a = 10;
	int b = 20;
	printf("交换前a=%d,b=%d\n", a, b);
	Swap(&a, &b);
	printf("交换后a=%d,b=%d\n", a, b);
	return 0;
}

函数定义：Swap(int *pa,int *pb)__形式参数：函数调用完会销毁，只在函数内有效
函数调用Swap(&a, &b);__实际参数

嵌套调用

函数可以嵌套调用，但是不能嵌套定义。

void new_line()
{
	printf("hehe\n");
}
void three_line()
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		new_line();//在three_line()中嵌套new_line()
	}
}
int main()
{
	three_line();
	return 0;
}

定义 声明

//包含头文件__：#include “add.h”
//导入静态库.ib__：#pragma commen(lib,“add.lib”)

链式访问

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

int main()
{
	char arr[20] = "hello";
	int ret = strlen(strcat(arr, "bit"));
	//strcat():Append a string.
	printf("%d\n", ret);
	return 0;
}

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	//结果是:4321
	//注：printf函数的返回值是打印在屏幕上字符的个数
	return 0;
}

名称	值	类型
printf(“%d”, 43)	43	int
printf(“%d”, printf(“%d”, 43))	2	int
printf(“%d”, printf(“%d”, printf(“%d”, 43)))	1	int

递归

函数自己调用自己
通常把一个大型复杂的问题转化为一个与原问题相似的规模较小的问题来求解，
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，减少了程序的代码量。
递归的必要条件

1. 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2. 每次递归调用之后越来越接近这个限制条件。

int main()
{
	printf("hello\n");
	main();
	return 0;
	//0x79493499 (ucrtbased.dll) (25-1-6.exe 中)处有未经处理的异常:
	//0xC00000FD: Stack overflow (参数: 0x00000000, 0x01002000)。
	//Stack overflow：栈溢出，死递归导致的，递归无法结束

}

eg1：接受一个整型值（无符号），按照顺序打印它的每一位。
输入：1234，输出 1 2 3 4

scanf("%d", &num);1234%10=4
1234/10=123;123%10=3
123/10=12;12%10=2
12/10=1;1%10=1
1/10=0//结束  

void print(unsigned int n)
{
	if (n > 9)//一直递归，直到n < 9，，，Stack overflow：栈溢出，死递归
	{
		print(n / 10);//开始递归，调用自己
	}
	printf("%d ", n % 10);
}

int main()
{
	unsigned int num = 0;
	scanf("%d", &num);
	print(num);
	return 0;
}

栈区	局部变量	函数形参	函数栈帧的空间的开辟都是在栈区
堆区	动态内存分配
静态区	全局变量	静态变量

每一次函数调用，都在栈区导航分配一块内存空间，用来保存函数在调用过程中的上下文信息。

开辟顺序	内存	栈区
5.	n=1	print	使用完就销毁空间
4.	n=12	print	使用时开辟空间
3.	n=123	print
2.	n=1234	print
1.	num=1234	main	main函数结束也销毁空间

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

1. 求字符串的长度

int my_stelen(char* s)
{
	int count = 0;
	while (*s != '\0')//输入字符串为abc，内存中为a b c \0
	{
		count++;
		s++;
	}
	return count;
}

int main()
{
	char arr[] = "abc";
	int len = my_stelen(arr);
	printf("%d", len);
	return 0;
}

2. 不允许创建临时变量count
   使用递归
   my_strlen(“abc”)
   1+my_strlen(“bc”)
   1+1+my_strlen(“c”)
   1+1+1+my_strlen(“\0”)
   1+1+1+0

int my_strlen(char* s)
{
	if (*s == '\0')//注意内部比较用==，不可以使用赋值号=！！！！！
		return 0;
	else
		return 1 + my_strlen(s + 1);
}

int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d", len);
	return 0;
}

迭代（循环）

eg1.求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 ret = Fac(n);
	printf("%d", ret);
	return 0;
}

eg2.求第n个斐波那契数。（不考虑溢出）
1 1 2 3 5 5 8 13 21 34 55 …,两数和为第三数

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", ret);
	return 0;
}

在使用 fib 函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。 2^48
使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。2^32 =42亿
改进：迭代写法

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;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("%d", ret);
	return 0;
}