函数
?
一个大型程序的部分代码，由一个或多个语句块组成，它负责完成某种特定的任务，而且相较于其他代码具有独立性。
一般会有输入参数并有返回值，它提供了对过程的封装和细节的隐藏(黑匣子)，这些代码通常被称为软件库。
库函数
把频繁，大量使用的功能提前写出来。在使用中就可以直接包含头文件然后使用其库函数。
所有库函数都是集成在头文件里
C语言库函数
- IO函数
? ????????? ? ? 输入输出，printf,scanf getchar putchar等等
- 字符串操作函数
? ????????? ? ? 操作字符串 strcmp strlen等等
- 字符操作函数
? ? ? ????????? 操作字符 toupper(小写转大写)等
- 内存操作函数
????????????????memcpy memcmp memset 等
- 时间/日期函数
????????????????time 等
- 数学函数
????????????????sqrt pow 等
- 其他库函数
比如：
strcpy
char * strcpy ( char * destination , const char * source);
把source指向的空间的字符串拷贝到destination指向的空间里
#include<string.h>
#include<stdio.h>
int main()
{
char a[] = "Hello Word";
char b[] = "ERORR";
printf("a=[%s]\nb=[%s]\n", a, b);
//strcpy(b, a);因为计算机给b字符数组分配的内存空间装不下"Hello Word"所以这里会编译报错
strcpy(a, b);//反之则可以
printf("a=[%s]\nb=[%s]\n", a, b);
return 0;
}注意，a拷贝到b，b的内存空间要大于等于拷贝内容才能有效，否则编译不通过。?
数组名就是数组的地址
自定义函数
由程序员自己创建的函数
函数返回类型 函数名(函数参数1,函数参数2)
{
? ? ? ?语句;
}//函数体#include<stdio.h> int get_Max(int a, int b)//定义返回类型为int的自定义函数 { if (b > a) { int n; n = a; a = b; b = n; } return a;//返回变量a的值 } int main() { int a; int b; scanf("%d%d", &a, &b); int n = get_Max(a, b);//将a，b的参数传递过去。 printf("最大的值：%d", n); return 0; }
函数的调用
传值调用
函数的参数分为形参和实参，他们分别占不同的区块，对形参的修改不影响实参。
传址调用
把函数外部创建的变量的内存地址传递给函数参数。
这种传值可以让函数和函数外边的变量建立起正真的联系(直接访问地址了)，函数内部可以直接操纵函数外部的变量。
#include<stdio.h>
int add(int a, int b)
{
return a + b;//通过返回值来达到效果
}
void add_1(int* pa, int* pb, int* pc)//因为不需要返回值，所以直接使用void
{
*pc = *pa + *pb;
}//直接操作地址空间存储的值来改变变量的值
int main()
{
int a = 5;
int b = 6;
int c = 0;
add_1(&a, &b, &c);
printf("%d", c);
c = a + b;
printf("%d", c);
return 0;
}
函数要保持单一化，独立化，不要做无关的事。
函数的嵌套调用和链式访问
嵌套调用
函数不能嵌套定义，但可以嵌套调用。
#include<stdio.h>
void reduce(int* pa, int* pb, int* pc)
{
*pc = *pa - *pb;
}
void add(int* pa, int* pb, int* pc)
{
*pc = *pa + *pb;
}
int run(int a, int b)
{
int c;
if (a < b)
{
add(&a, &b, &c);//嵌套调用add自定义函数
}
else if (a > b)
{
reduce(&a, &b, &c);
}
else {
return 0;
}
return c;
}
int main()
{
int a, b;
scanf("%d%d", &a, &b);
printf("%d", run(a, b));
return 0;
}链式访问
把一个函数的返回值作为另一个函数的参数。
#include<stdio.h>
int add(int a, int b) {
return a + b;
}
int main()
{
int a = 5;
int b = 6;
int c;
c = add(a, b);
printf("%d", add(a, b));
//直接调用函数，就是链式访问
printf("%d", c);
}
printf()函数的链式访问
#include<stdio.h>
int main()
{
int c = 43;
printf("%d", printf("%d", printf("%d", c)));
//printf()函数的链式访问，打印结果为4321
//因为printf()返回的值是打印字符的个数。
return 0;
}因为printf的返回值是打印字符的个数，所以结果为4321。
所以，使用链式访问时，要确定调用函数返回的值。
函数的声明和定义
函数的声明
告诉编译器一个函数叫什么，参数是什么，返回类型是什么。?
函数的声明一般在函数使用前。
函数的定义一般放在头文件中。
函数的定义
函数的定义一般是交代函数的具体实现，交代函数的功能。
导入静态库
#pragma commet(lib,"静态库名称加后缀")函数递归
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法。
它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归策略只需要少量的程序就可描述出解题过程所需要的多次重复运算。，大大减少了程序的代码量。
递归的主要思想：大事化小
假设输入一段数字1234，分开输出1 2 3 4
按照编程思想，1234%10=4；得到最后一位
1234/10=123，123%10=3，得到第二位，依次推类。1234/%10=4
1234/10=123????????123%10=3
123/10=12? ? ? ? ? ? 12%10=2
12/10=1? ? ? ? ? ? ? ? 1%10=1
1/10=0我们假设一个函数print()
print(1234)? ? ? ? ?//把一个print函数问题拆分成一个print函数和一个直接打印
print(123)? ? ? ? 4
print(12)? ? ? ? ??3? ? ? ? 4
print(1)? ? ? ? ? ? 2????????3? ? ? ? 4
#include<stdio.h>
print(unsigned int n)
{
if (n > 9)
{
print(n / 10);
}
printf("%d\t", n % 10);
}
//假设输入值为123
//上述代码可以理解为
//if (123 > 9)
//{
// if (12 > 9)
// {
// if (1 > 9)
// {
// ;
// }
// printf("%d", 1);
// }
// printf("%d", 2);
//}
//printf("%d", 3);
//
//
//
int main()
{
unsigned int n = 0;
scanf("%d", &n);
print(n);
return 0;
}在return里使用递归
自定义函数计算字符串的字符个数，要求不能在函数里创建变量。
#include<stdio.h>
int str(char* arr) {//因为是数组，使用指针更方便
//因为要求不能创建临时变量，且我们需要返回值，所以我们只能在return里动手脚
if (*arr != '\0')//如果*arr指向的内存空间的值不等于字符串的最后一位
//指针向字符串后移动一位，指向下一位字符
return 1 + str(arr + 1);//利用函数递归的特性，返回下一位字符的str计算结果，依次套娃到结束符，
//然后所有的return依次返回到上一个str函数最后返回给main函数
else
return 0;//如果第一个字符就是\0
}
int main()
{
char arr[] = "Hello Word";
//自定义函数计算字符串长度，要求不能创建临时变量
int n = str(arr);
printf("%d", n);
return 0;
}递归里不建议使用++这种运算符。
利用递归实现n的阶乘。
#include<stdio.h>
int var(int n)
{
if (n != 0) {
return n * var(n - 1);
}
else
{
return 1;
}
}
int main()
{
int n = 3;
printf("%d", var(n));
return 0;
}递归不是万能的，大量重复计算下，递归的效率比迭代要低
#include<stdio.h>
int c = 0;
int add(int n) {
c++;
if (n <= 2)
{
return 1;
}
else
{
return add(n - 1) + add(n - 2);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int k[100];
int j = 0;
int i;
k[0] = 1;
k[1] = 1;
for (i = 2; i < n; i++) {
k[i] = k[i - 1] + k[i - 2];
}
printf("迭代%d\t循环%d次", k[i - 1], i - 1);
printf("\n递归%d\t循环%d次", add(n), c);
return 0;
}当输入20时
差别之大。
?
数组
一组相同类型的集合
一维数组
数组的初始化
int arr[ ];
方括号内只能输入常量（C99语法支持变量：变长数组）
初始化分为完全初始化和非完全初始化
int arr[5]={ 1,2,3,4,5};//完全初始化
int arr[5]={1,2,3,4}//非完全初始化，arr[4]的值为0int arr[ ]={1,2,3,4,5}它会根据大括号内容来确定数组个数
字符数组中，不完全初始化中未初始化的内容为0也就是\0
字符串数组中，字符串末尾的结束符‘\0’也会自动计算在数组中
PS：字符数组中因为没有结束符，如果定义的数组大于字符串或者未定义大小，会出现乱码
#include<stdio.h>
int main()
{
char ch1[]= {'H','e','l','l','o'};
char ch2[]= {'H','e','l','l','o','\n'};
printf("%s\n",ch1);
printf("%s",ch2);
return 0;
}
??
一维数值的使用
?通过数组下标来操纵数组
下标默认从0开始
[]下标引用操纵符
#include<stdio.h>
int main()
{
int arr[10] = { 0 };//初始化必须赋予值
arr[5] = 5;
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("%d", arr[i]);
}
return 0;
}一维数组在内存中的储存
十六进制内存地址，按照0-9 a b c d e f 轮流排序 a-f是10到15，一共16个
不同位数的系统内存地址长度输出也不一样
一维数组的地址是连续存放的
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
for (int i = 0; i < 10; i++)
{
printf("%p\n", &arr[i]);
}
return 0;
}*86? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? *64
?由上图可以知道，每一个数组之间，相差4个字节，也就是说单个数组在内存中占4个字节大小
?随着下标的增长，地址是由低到高变化的。
用指针操纵数组
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
for (int i = 0; i < 10; i++)
{
printf("%p\n", &arr[i]);
}
int* p = arr;//数组名就是其数组地址
for (int i = 0; i < 10; i++)
{
printf("\n%d", *p);
p++;//指针指向的位置向下一个内存空间移动
}
return 0;
}?二维数组
创建和初始化
int arr[3][4]； 假象为三行四列
int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};会直接把数据扔进去
二维数组的不完全初始化和一维数组一样后面补0
int arr[2][2] = {{1,2},{3,4}}//一个括号就是一层数组
二维数组的行可以省略掉，列不行
int arr[][2]= {{1,2},{3,4}}
原因是因为它会根据后面的数据来调整来设置有多少行
二维数组的操作
通过循环嵌套访问控制二维数组
#include<stdio.h>
int main()
{
int arr[4][4] = { 0 };
arr[2][2] = 5;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%d\t", arr[i][j]);
}
printf("\n");
}
return 0;
}
?二维数组的内存操作
#include<stdio.h>
int main()
{
int arr[4][4] = { 0 };
int sz_1 = sizeof(arr) / sizeof(arr[0]);//计算第一层数组的长度
int sz_2 = sizeof(arr[0]) / sizeof(arr[0][0]);//计算第二层数组的长度
printf("arr=%d\n", sizeof(arr));
printf("arr[0]=%d\n", sizeof(arr[0]));
printf("arr[0][0]=%d\n", sizeof(arr[0][0]));
for (int i = 0; i < sz_1; i++)
{
for (int j = 0; j < sz_2; j++)
{
printf("%p\t", &arr[i][j]);
}
printf("\n");
}
return 0;
}
?可看到，二维数组的内存地址和一维数组一样，都是依次增加。