C语言 函数 上

函数的定义：子程序 是一个大型程序中的某部分代码，由一个或多个语句块组成，它负责完成某项特定任务，相较于其他代码，具备相对的独立性
2.库函数 eg:打印函数:printf    字符串拷贝:strcpy    计算n的k次方:pow函数
3.自定义函数
4.函数参数
5.函数调用
6.函数的嵌套调用和链式访问
7.函数的声明和定义
8.☆☆☆☆☆☆  函数递归 ☆☆☆☆☆☆

函数具备相对独立性 由一个或者多个语句块组成，负责完成某项特定任务
一般会有输入参数并由返回值，提供对 过程 的封装和细节的隐藏，这些代码通常被集成为软件库

函数分为两类：1.库函数    2.自定义函数
库函数：C语言提供的标准代码，为了提高效率和可移植性， 编译器厂商 提供了一系列 库函数
C语言标准中约定好，由编译器的厂商提供实现
eg.C语言标准规定：strlen 函数的功能：求字符串的长度 函数名：strlen 参数：const char* str 返回类型 size_t
库函数：标准库中规定好的函数 
使用库函数：提高效率，帮助程序员软件开发
头文件中包含函数

常用的库函数有：
1.IO函数（输入输出函数）
2.字符串操作函数
3.内存操作函数
4.时间/日期函数
5.数学函数（math.h)
6.其他库函数

次方，pow 次方函数: 
#include <math.h> 对应的数学的头文件

int main()
{
	long long int n = (long long int)pow(2,6);//二的五次方
	double a = (double)pow(5.2, 3.0);
	printf("%lf\n", a);
	printf("%lld\n", n);
	return 0;
}

#include <string.h>
strcpy函数: 复制字符串 把一个数组指向的字符串拷贝在另一个数组中

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello C";
	strcpy(arr1, arr2);//将数组2 arr2中的字符拷贝到数组1  arr1中打印  arr1目标空间的地址
	printf("%s\n", arr1);
	printf("%s\n", strcpy(arr1, arr2));
	//返回目标空间的地址
	return 0;
}

memest函数 内存设置函数 内存：memory

int main()
{
	char arr[] = "hello C";//memset函数将hello C 中 hello全部改变
	memset(arr, 'c', 7);//arr中的数组 改为c 共五个字节
	char arr1[] = "一切都会好的";
	memset(arr1, 'l', 4);
	printf("%s", arr1);
	printf("%s", arr);
	return 0;
} 

\0是字符串结束标志
库函数查询工具的使用：www.cplusplus.com
http://en.cpprerence.com 英文版
http://zn.cpprerence.com 中文版
         /*************自定义函数**************/
函数的组成：函数名  函数参数  返回类型  函数体
eg.写一个函数找出两个整数中的最大值 返回较大值整数

int main()
{
	printf("请您输入两个整数：");
	int a, b;
	scanf("%d %d", &a,&b);
	int c = max(a, b);
	printf("%d\n", c);
	printf("%d\n", max(a, b));
	return 0;
}//库函数 开箱即用

编写一个函数 比较两个数中的最大值

int Max(int a, int b)
{
	if (a >= b)
	{
		printf("%d", a);
	}
	else
	{
		printf("%d", b);
	}
}

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

错误传参方法：
写一个函数交换两个整形变量内容
形式参数 形参 赋值临时变量第三个瓶子

void change(int x, int y)
{
	int t = 0;
	t = x; 
	x = y;
	y = t;
}

int main()
{
	int a, b;
	scanf("%d %d", &a, &b);
	printf("交换前：%d %d", a, b);

	//实际参数 实参
	change(a, b);
	//函数调用的时候就，将实参传递给形参
	//形参是实参的一份临时拷贝
	//对形参的修改不会改变实参的大小
	printf("交换后：%d %d", a, b);
	return 0;
}

int main()
{
	int num = 10;
	int* p = #//将num的地址传给指针变量，让指针变量进行保存，函数内外部之间没有联系
	//通过指针变量赋值，将地址联系起来，从而改变原参数的值。
	*p = 20;

	printf("%d\n", num);
	return 0;
}

 正确传参方式：
写一个函数交换两个整形变量内容
*变量存地址指针 地址变量

void change(int*a, int*b)//交换p1 p2顺序 交换地址，传递地址 交换顺序 *a *b代表指针代表地址
{
	int tmp = 0;//创建临时变量
	tmp = *a;//tmp=num1;
	*a = *b; //num1=num2;
	*b = tmp;//num2=tmp;
}

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

	printf("交换前：num1 = %d num2 = %d", a, b);

	//实际参数 实参
	change(&a, &b);
	//函数调用的时候就，将实参传递给形参
	//形参是实参的一份临时拷贝
	//对形参的修改不会，改变实参的大小

	printf("交换后：num1 = %d num2 = %d", a, b);
	return 0;
} 

实参：真实传给函数的参数，叫做实参,可以是常量，变量，表达式，函数等
形参：指函数名后括号中的变量。因为形参只有在函数被调用的过程中才实例化（分配内存单元）
不调用函数时，形参只是一个形式，函数只有被调用的时候，形参才会被分配变量，形参相当于局部变量，只在函数内部有效
函数不被调用时，函数中的形参变量是一个模板，函数只有在被调用时，才会给参数分配空间
形参实例化后相当于实参的一份临时拷贝

例如、

int Max(int x, int y)
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}

void print()
{
	printf("一切都会好的\n");
}

int main()
{

	int num1, num2;
	scanf("%d %d", &num1, &num2);
	int b = Max(1 * 9, 81 / 3);
	printf("b:%d\n", b);
	int a = Max(num1, num2);
	printf("max:%d\n", a);
	print();
	return 0;
}

函数的调用：
传值调用 传址调用：
传值调用：只需要求值，和值有关，形参只能临时拷贝，对形参的修改不会影响实参
传址调用：把函数外部创建变量的内存地址传递给函数参数的一种调用方式，也就是函数内部可以直接操作函数外部的变量，
当你需要在函数内部修改来自函数外部的变量时，用传址调用，但是传址的本质也是传值调用
区分只有场景的不同

写一个函数判断是不是素数 是素数返回1，不是素数返回.

int is_prime(int n)
{
	//拿2~sqrt(n)开平方n之间数字试除 sqrt:开平方
	int i = 0;//判断变量
	for(i=2;i<=sqrt(n);i++)
	{
		if (n % i == 0)
			return 0;//直接返回，后面的循环不再执行
		//return比break效果更强
	}
	return 1;
}

int main()
{
	int i = 0;
	int count = 0;
	for (i = 100; i <= 200; i++) {
		if (is_prime(i))
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\ncount=%d\n", count);
	return 0;
} 

Bool类型进行判断 <stdbool.h>
_Bool 类型的变量只有两种取值 true和false

bool Judge(int a)
{
	int i = 0;
	for (i = 2; i <= sqrt(a); i++)
	{
		if (a % i == 0)
		{
			return false;
		}
	}
	return true;
}

int main()
{
	int count = 0;
	int a = 0;
	for (a = 100; a <= 200; a++)
	{
		if (Judge(a))
		{
			count++;
			printf("%d ", a);
		}
	}
	printf("一共有：%d 个素数\n", count);
	return 0;
}

 写一个函数判断是不是闰年
打印1000—2000年之间的闰年 

方法1：

bool year(int y)
{
	if ((y % 400 == 0 ) || (( y % 4 == 0) && (y % 100 != 0)))
		return true;
	else
		return false;
} 
int main()
{
	int y = 0;
	int count = 0;
	for (y = 1000; y <= 2000; y++)
	{
		if (Year(y))
		{
			count++;
			printf("%d ", y);
		}
	}
	printf("count=%d\n", count);
	return 0;
}

方法 2：

int Year(int y)
{
	if ((y % 400 == 0) || ((y % 4 == 0) && (y % 100 != 0)))
		return 1;
	else
		return 0; 
}
int main()
{
	int y = 0;
	int count = 0;
	for (y = 1000; y <= 2000; y++)
	{
		if (Year(y))
		{
			count++;
			printf("%d ", y);
		}
	}
	printf("count=%d\n", count);
	return 0;
}

键盘输入一个数，判断是闰年平年 方法1:

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


int main()
{
	int year = 0;
	scanf("%d", &year);
	if (Year(year))
	{
		printf("%d是闰年\n", year);
	}
	else
	{
		printf("%d不是闰年\n", year);
	}
	return 0;
}

键盘输入一个数，判断是闰年平年 方法2:

bool Judge(int a)
{
	if ((a % 400 == 0) || ((a % 4 == 0) && (a % 100 != 0)))
		return true;
	else
		return false;
}


int main()
{
	int year = 0;
	printf("请您输入一个年份:\n");
	scanf("%d", &year);
	if (Judge(year))
	{
		printf("%d是闰年\n", year);
	}
	else
	{
		printf("%d不是闰年\n", year);
	}
	return 0;
}

写一个函数，实现一个整形有序数组的二分查找
找到了就返回下标，找不到返回0;
结果容易溢出，此方法不好。
有序数组：用二分查找

int beat(int arr[], int k, int sz)
{
	int left = 0;
	int right = sz - 1;//元素数-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]);//数组个数 sizeof(arr[])
	int ret = beat(arr, k, sz);//k：在数组中寻找的元素
	if (ret == -1) 
	{ 
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是%d\n", ret);
	}
	return 0;
}

数组元素过多 防止数据溢出 改造方法:
改造方法
值太长，结果溢出。
int main()
{
    int num1 = 2147483646;
    int num2 = 2147483644;
    int vag = num1 + (num1 - num2) / 2;
    printf("%d\n", vag);
    return 0;
}

写一个函数，每调用一次这个函数，就会将num的值加一,方法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 n = 0;
	int num = 0;
	num = Add(num);
	printf("%d\n", num);
	num = Add(num);
	printf("%d\n", num);
	for(n=1;n<=15;n++)
	{
		num = Add(num);
		printf("%d\n", num);
	}
	return 0;
}

函数的嵌套和调用
函数可以嵌套调用，但是函数不能嵌套定义,不能在一个函数的定义在再定义一个函数
一个函数中不能定义另一个函数，函数不能嵌套定义

函数之间可以嵌套调用 但是函数之间不能嵌套定义

链式访问:把一个函数的返回值当作另一个函数的参数 叫做链式访问

int main()
{
	int len = strlen("abc");
	printf("%d\n", len);
	printf("%d\n", strlen("abc"));
	char arr1[20] = { 0 };//abc\0......
	char arr2[] = "abc";
	printf("%d\n", strlen(strcpy(arr1, arr2)));
	//strcpy函数将arr2的地址赋值给arr1.strlen函数计算赋值后字符串的长度
	return 0;
}

eg:链式访问

int main()
{
	printf("%d", printf("%d", printf("43")));
	//打印43时返回2，打印2时返回1，利用了函数的链式访问，把一个函数的返回值当作另一个函数的参数 叫做链式访问
	//4321 返回值4321 利用了链式访问 不能加入\n 
	printf("\n");
	printf("%d ", printf("%d ", printf("43 ")));
	//打印4332
	return 0;
}