函数与函数递归

函数

库函数

IO函数 printf scanf getchar putchar
字符串操作函数 strcpy strcat strcmp strlen
字符操作函数 toupper tolower
内存操作函数 memset memmove memcpy memcmp
时间/日期函数
数学函数 sqrt pow
其他库函数

函数声明和定义

函数声明

告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。
函数的声明一般出现在函数的使用之前。要满足先声明后使用。
函数的声明一般要放在头文件中的。

函数定义

函数的定义是指函数的具体实现，交待函数的功能实现。

//test.c
//add.c
//add.h
#include "add.h"
//分块写，有好处
//1.多人协作
//2.封装与隐藏

函数递归

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

#include <stdio.h>
void print(int num)
{
	if (num > 9)
	{
		print(num / 10);
	}
	printf("%d ", num % 10);
}

int main()
{
	size_t num = 0;
	print(num);
	return 0;
}

每一次函数调用多要在栈区开辟空间，如果无限递归下去，会造成栈溢出。

函数调用结束后，会把空间还给操作系统，每次开辟的空间叫函数栈帧。

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

#include <string.h>

my_strlen(char* p)
{
	if (*p != '\0')
	{
		return 1 + my_strlen(p+1);
	}
	else
	{
		return 0;
	}
}

int main()
{
	char arr[10] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);
}

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

• 求第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);
	int ret = Fib(n);
	printf("%d\n", ret);
	return 0;
}

但是我们发现有问题：

在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

解决办法：用迭代（循环）

int Fac(int n)
{
	int ret = 1;
	while (n > 1)
	{
		ret *= n;
		n--;
	}
	return ret;
}

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

int Fib(int n)
{
	int ret = 1;
	int a = 1;
	int b = 1;
	while (n > 2)
	{
		a = b;
		b = ret;
		ret = a + b;
		n--;
	}
	return ret;
}

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

自定义函数练习

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

#include <stdio.h>

Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	Swap(&a, &b);
	printf("a=%d b=%d\n", a, b);
	return 0;
}

形参只是实参的临时拷贝，它们分别占用独立的空间，改变形参无法改变实参
传值调用
传址调用

• 写一个函数可以判断一个数是不是素数

#include <stdio.h>

int is_prime(int a)
{
	int i = 0;
	for (i=2; i<a-1; i++)
	{
		if (a % i == 0)
			return 0;
	}
	return 1;
}

int main()
{
	int a = 0;
	scanf("%d", &a);
	int ret = is_prime(a);
	if (ret == 1)
		printf("是素数\n");
	else
		printf("不是素数\n");
	return 0;
}

• 写一个函数判断一年是不是闰年。

int is_leap_year(int year)
{
	if ((year%4==0 && year%100!=0) || (year%400==0))
		return 1;
	else
		return 0;
}

int main()
{
	int year = 0;
	int count = 0;
	for (year=1000; y<=2000; y++)
	{
		if (is_leap_year(year) == 1)
		{
			printf("%d ", year)
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}

• 写一个函数，实现一个整形有序数组的二分查找（二分查找算法）。

int binary(int arr[], int sz, int k)
{
	int left  = 0;
	int right = sz-1;
	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] > k)
			right = mid - 1;
		else if (arr[mid] < k)
			left = mid + 1;
		else
			return mid;
	}
	return 0;
}

int main()
{
	int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	int sz = sizeof(arr) / sizeof(arr[0]);
	int k = 0;
	scanf("%d", &k);
	int ret = binary_search(arr, sz, k);
	if (ret == 0)
		printf("找不到\n");
	else
		printf("找到了，下标为%d\n", mid);
	return 0;
}

• 函数嵌套调用

函数可以嵌套调用，不可以嵌套定义

• 函数链式访问

printf("%d\n", strlen("abc"));
printf("%s\n", strcpy(str1, str2));
//以上就叫做函数链式访问

#include <stdio.h>
int main()
{
	printf("%d", printf("%d", printf("%d", 43)));//4321
	//结果是啥？
	return 0;
}

printf函数返回的是打印在屏幕上的字符的个数
如果发生错误，将返回函数