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
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
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类型进行判断
_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;
}