C语言—知识点—函数

示例一

写一个函数，每调用一次num的值就会加1.

void Add(*p)
{
   (*p)++;
}

//也可以写成

//int Add(int n)
//{
//   return (++n);
//}

int main()
{
   int num=0;
   num=Add(num);
   return 0;
}

函数的嵌套调用与链式访问

注意：函数可以嵌套调用，但是不可以嵌套定义。

链式访问示例

printf（"%d",printf("%d",printf("%d",43)));

printf 函数的返回值是在屏幕上打印的字符的个数 。

所以打印结果为4321。

示例二

写一个函数交换两个整型变量。

（错误写法）

void Swap(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

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

//以上写法a，b的值并没有改变

注意：当实参传给形参的时候，形参是实参的一份临时拷贝。改变函数的形参不会改变实参 。

（正确写法）

void Swap(int* px, int* py)
{
	int z = 0;
	z = *px;
	*px = *py;
	*py = z;
}

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

//通过指针找到实参

示例三

写一个函数判断闰年，并打印1000-2000的闰年。 

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

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

bool类型

 c99标准才能使用。判断真假的类型，要引头文件。

#include<stdbool.h>

bool is_prime(int n)
{
	if (n < 10)
		return false;
	else
		return true;
}

函数递归 

什么是递归？

程序调用自身的编程技巧称为递归。

他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，

只需要少量的程序就可描述出解题过程所需要的多次重复计算，减少了程序的代码量。

递归的两个必要条件：

1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。

2.每次递归调用之后越来越接近这个限制条件。

示例：

接收一个整型值（无符号），按照顺序打印它的每一位。

例如：1234，输出 1 2 3 4.

void print(unsigned int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d", n % 10);
}

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

 递归与迭代

示例：

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

（迭代法）

int fac(int n)
{
	int i = 0;
	int ret = 1;
	for (i = 1;i <= n;i++)
	{
		ret *= i;
	}
	return ret;
}

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

注意：不是死递归，但是如果递归的层次太深仍有可能出现栈溢出。 

库函数1：strcpy函数

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello bit";

	strcpy(arr1,arr2);
	printf("%s\n", arr1);
	return 0;
}

注意:  第一个参数是目的地，第二个参数是源头。将arr2中的字符串拷贝到arr1中。

库函数2：memset函数

把某一位置开始向后特定个数的字节设置为某一值 

int main()
{
	char arr[20] = "hello world";
	memset(arr, 'x', 5);
	printf("%s", arr);
	return 0;
}

输出结果： 

注意：库函数的使用一定要包含对应的头文件。