C语言 ——— 认识C语言

认识 main 函数

main 函数是程序的入口，程序执行时会从 main 函数的第一行开始执行，且一个工程中 main 函数有且只有一个

标准的 main 函数格式：

int main()
{return 0;
}

int 是类型，这里指的是 main 函数的返回类型

return 是返回的意思，通常 main 函数返回 0，表示正常结束程序

古老的 main 函数格式：

void main()
{}

这是比较古老的 main 函数格式，void 表示没有返回值，不用 return 返回

如果书籍或者教材中有这种 main 函数的写法，大概率可以不用看了

不接受参数的 main 函数格式：

int main(void)
{return 0;
}

main 函数括号中的 void 表示这个 main 函数不接受任何参数

---

sizeof 操作符

sizeof 操作符的作用是计算 类型/变量 所占内存空间的大小，单位是字节（byte）

sizeof 计算内置类型所占空间的大小：

int main()
{printf("%d\n", sizeof(char));printf("%d\n", sizeof(short));printf("%d\n", sizeof(int));printf("%d\n", sizeof(long));printf("%d\n", sizeof(long long));printf("%d\n", sizeof(float));printf("%d\n", sizeof(double));return 0;
}

%d 的意思是以 10 进制的形式打印一个整数，因为 sizeof 关键字的返回类型是整形，所以使用 %d 的形式打印

运行代码：

可以看到 char 类型所占内存空间大小为 1 字节、short 类型所占空间大小为 2 字节...

因为 C语言 规定，只要 sizeof(long) >= sizeof(int) 即可，所以 sizeof(long) 的大小是 4 字节，在有些平台下 sizeof(long) 的大小是 8 字节

---

全局变量和局部变量

代码演示：

int b = 100;int main()
{int a = 10;return 0;
}

定义在 main 函数内部的变量 a 就是局部变量

定义在 main 函数外部的变量 b 就是全局变量

生命周期：

变量 a 的生命周期是在 main 函数内部，当 mian 函数执行完了 return 后，变量 a 的生命周期就结束了

变量 b 的生命周期是整个工程结束时，变量 b 的生命周期才结束

当全局变量的变量名和局部变量的变量名冲突时：

int a = 100;int main()
{int a = 10;return 0;
}

通过 printf 函数测试代码是否能正常执行，并且测试出有限执行的哪个变量

测试代码：

可以看到，优先执行了局部的变量 a

小结：

首先原则上变量名尽量不要冲突，但是当全局变量和局部变量的名字冲突的情况下，局部变量优先

---

extern 关键字

extern 关键字的作用是声明外部符号

例如：

有两个 .c 文件，分别为 add.c 文件和 test.c 文件

add.c 文件的代码：

int a = 2025;

那么想要在 test.c 文件中使用 add.c 文件中的变量 a，就需要使用 extern 关键字

test.c 文件使用变量 a：

extern int a;int main()
{printf("a = %d\n", a);return 0;
}

要想使用 add.c 文件中的变量 a，要先在 test.c 文件中对变量 a 进行声明，才能正常使用

运行 test.c 文件：

---

常量

字面常量

字面常量顾名思义就是字面意义的常量，不能改变的量就叫常量

比如：圆周率、由 0-9 组成的数字、字符、字符串... 

const 修饰的常变量

代码演示：

const int a = 10;

定义了一个 int 类型的变量 a，并且这个变量 a 被 const 修饰了，此时 a 就具有了常属性

也就表示 a 的值不能被改变了，只能在初始化的时候赋值

且 a 本质还是一个变量，因为不能给数组定义长度，只是 a 这个变量不能被修改，所以称 a 为常变量

#define 定义的标识符常量

代码演示：

#define SIZE 10

这个代码可以理解为给 10 这个常量取了一个名字叫 SIZE，此时的 SIZE 就是标识符常量

那么 SIZE 就能给其他同类型的变量赋值，且可以给数组定义长度

在执行代码时，程序会把有 SIZE 的地方全部替换为常量 10

枚举常量

枚举常量顾名思义是能被一一列举的常量，比如：性别、三原色、血型等

代码演示：

enum COLOR
{Red,Green,Blue
};

enum 是定义枚举常量的关键字，COLOR 是枚举常量的结构体名称

其中 Red、Green、Blue 是枚举出的三原色，他们都有各自的默认值，Red 是 0，后面的依次递增

代码测试：

可以在初始化的时候重新给他们赋值，并且还是遵循依次递增的规定

---

'\0' 是字符串结束标志

'\0' 是表示字符串结束的标志，不论是用 %s 打印字符串，还是用 strlen 函数求字符串长度，都是遇到 '\0' 才结束，否则就会一直执行，知道遇到 '\0' 才停止

%s 打印字符串

%s 表示的是打印一串字符，一般和 printf 函数配合使用

代码演示：

char arr1[] = { 'a','b','c','d' };
char arr2[] = "abcd";

在数组 arr1 中存储了 4 个字符，但在数组 arr2 中不只是存储了 "abcd" 字符串，在 "abcd" 字符串末尾还存放了一个 '\0'

可以通过监视验证：

那么以 %s 分别打印两个数组时，arr1 数组就会除了打印字符还会打印其他未定义字符，直到遇到 '\0' 才会停止

代码验证：

strlen 函数

strlen 函数的作用是求字符串长度，所需要的头文件为 #include<string.h>

且 strlen 函数同样是求到 '\0' 之前的长度，当没有 '\0' 的话就会一直求长度，直到遇到 '\0' 为止

代码验证：

因为不知道数组 arr1 何时遇到 '\0' ，所以是随机值

解决办法：

可以在 arr1 数组中手动加上 '\0'

代码演示：

char arr1[] = { 'a','b','c','d','\0' };

 这样不论是 %s 打印还是 strlen 求长度，都能正常输出结果

---

转移字符 \ddd 和 \xdd

转移字符 \ddd

其中 ddd 表示 1~3 个八进制的数字

代码演示：

printf("%d\n", '\130');

%d 是以十进制的方式打印，那么 130 这个八进制数字转换为十进制为 88 

因为 130 各自的权重相乘在相加为 0*8^0 + 3*8^1 + 1*8^2 = 88

代码验证：

那么以 %c 字符形式打印，那么结果就会变成大写的 X，因为 88 所对应的 ASCII 码值就是 X

代码验证：

转移字符 \xdd

x 表示是十六进制的数字，其中 dd 表示 2 个十六进制的数字

代码演示：

printf("%d\n", '\x61');

十六进制的 61 转换为 十进制为：1*16^0 + 6*16^1 = 97

代码验证：

那么同样的道理，以 %c 的形式打印的话也就是打印 97 所对应的 ASCII 码值

代码验证：

测试题 

代码演示：

printf("%d\n", strlen("C:\test\127\x56\test.c"));

问：strlen 求出的长度是多少

易错点：其中 '\t'  '\127'  '\x56' 是转移字符，本质只占用1个字节

所以统计后的结果应该是 14 字节

代码验证：

---

选择语句

单分支选择语句

代码演示：

int a = 0;if (a == 0)
{printf("a == 0\n");
}
else
{printf("a != 0\n");
}

当满足 if 语句中的条件判断时，就不会执行 else 语句，否则就相反

所以代码中只会执行 if 语句内的代码 

多分支选择语句

代码演示：

int a = 0;if (a > 0)
{printf("a > 0\n");
}
else if (a < 0)
{printf("a < 0\n");
}
else
{printf("a == 0\n");
}

既不满足 if 语句的条件，也不满足 else if 语句的条件，所以最后会打印 else 语句中的代码 

---

循环语句

循环语句顾名思义就是循环执行循环内部的代码，直到满足特定的条件才会跳出循环 

while 循环语句

代码演示：

int a = 0;while (a < 5)
{printf("a = %d\n", a);a++;
}

满足条件，进入 while 循环，进入 while 循环时，先打印，变量 a 再自增 1 ，最后直到 a 不小于 5 时就循环结束

代码验证：

for 循环语句

代码演示：

for (int a = 0;a < 5;a++)
{printf("a = %d\n", a);
}

for(表达式1; 表达式2; 表达式3) 执行逻辑是：

先执行 表达式1，再判断 表达式2 是否满足条件，满足条件时进入 for 循环内部，执行完内部的代码后再回到 表达式3并且执行，执行完 表达式3 后再判断是否满足 表达式2 ，满足就再次进入循环（循环往复），不满足就跳出循环

代码验证：

do while 循环语句

代码演示：

int a = 0;do
{printf("a = %d\n", a);a++;} while (a < 5);

do while 循环语句的特点是：不论是否满足进入循环的条件，都会先进入循环内部执行一次代码，执行完之后再判断是否满足条件，满足就继续执行，不满足就跳出循环

代码验证：

break 关键字和 continue 关键字

break 关键字

break 关键字的作用是结束并且跳出当前循环

代码演示：

for (int a = 0;a < 5;a++)
{printf("a = %d\n", a);if (a == 3){break;}
}

当 a 等于 3 时就会执行 break，跳出循环

代码验证：

需要注意的是 break 只能跳出当前循环，如果是双重循环或者多重循环时，只能跳出 break 所在的那层循环

代码演示：

for (int i = 0;i < 1;i++)
{for (int a = 0;a < 5;a++){printf("a = %d\n", a);if (a == 3){break;}}printf("i = %d\n", i);
}

当内部循环走到 break 跳出时，外部的循环依然要执行

代码验证：

continue 关键字

continue 关键字的作用是跳过循环内部 continue 下面的代码，从头执行循环（当然要判断是否满足循环条件，满足再继续执行，否则就结束循环）

代码演示：

for (int a = 0; a < 5; a++)
{if (a == 3)continue;printf("a = %d\n", a);
}

当变量 a 等于 3 时就执行 continue，跳过后面的 printf 函数，重新执行循环

代码验证：

小结

break 和 continue 关键字只能在循环内部使用，否则就会报错 

---

scanf 函数的返回值

scanf 函数的功能可以从键盘上读取数据，并且存储到对应的变量中

而 scanf 函数的返回值是读取数据的个数

代码演示：

int a = 0;
int b = 0;int ret1 = scanf("%d", &a);
printf("ret1 = %d\n", ret1);int ret2 = scanf("%d %d", &a, &b);
printf("ret2 = %d\n", ret2);

第一个 scanf 函数只从键盘接收一个数据，并且用 ret1 接收 scanf 函数的返回值

第二个 scanf 函数从键盘接收了两个数据，分别打印 两个 scanf 函数的返回值，看是否分别是 1 和 2

代码验证：

注意：

当 scanf 函数没有正常接收数据时，会返回 EOF(文件结束标志)，可以通过让 scanf 函数接收 Ctrl+Z 键，就能返回 EOF  

---

牛刀小试

oj题 - 判断一个整数是否能被5整除 

题目描述：

输入一个正整数，判断这个数是否能被 5 整除，要求能多次输入输出

代码实现：

int input = 0;while (scanf("%d", &input))
{if (input % 5 == 0){printf("%d能被5整除\n", input);}else{printf("%d不能被5整除\n", input);}
}

代码解析：

直接利用 scanf 函数的返回值作为 while 循环的判断语句，只要正常接收了数据，就会进入循环

并且用 % 取模操作符进行判断，当 input%5 的余数为 0 时，就是能被 5 整除，否则就不能

代码验证：

oj题 - 计算 y 的值

题目描述：

已知一个函数 y=f(x)，当 x>0 时， y=1，当 x=0 时，y=0，当 x<0 时，y=-1

要求输入 x，求出对应的 y

代码演示：

int x = 0;
int y = 0;
scanf("%d", &x);if (x > 0)y = 1;
else if (x < 0)y = -1;
elsey = 0;printf("y = %d", y);

oj题 - 时间转换

题目描述：

给定秒数 seconds，把秒转换为小时、分钟、秒，并且分别输出

代码演示：

int seconds = 0;
scanf("%d", &seconds);int h = seconds / 3600;
int m = (seconds % 3600) / 60;
int s = seconds % 60;printf("%d秒 = %d小时%d分钟%d秒", seconds, h, m, s);

代码解析：

1 小时为 3600 秒，所以 seconds 除以 3600 秒就能计算出有多少个小时

seconds 取模上 3600 秒就能计算出不足一小时的有多少秒，再除以 60 秒，就能计算出还有多少分钟

seconds 直接取模上 60 秒，就能计算出不足以 60 秒的有多少秒

代码验证：

oj题 - 三角形判断

题目描述：

输入三角形的 3 条边 a、b、c，判断是否能构成三角形，如果不能构成三角形直接输出"Not a triangle!"，如果能构成三角形则判断这个是什么三角形，如果是等边三角形则输出"Equilateral triangle!"，如果是等腰三角形则输出"Isosceles triangle!"，如果是普通三角形则输出"Ordinary triangle!"，并且要求能多组输入输出

代码演示：

int main()
{int a = 0;int b = 0;int c = 0;while(scanf("%d %d %d", &a, &b, &c) == 3){if (a + b > c && a + c > b && b + c > a) //先判断是否能构成三角形：任意两边之和不能大于第三边{if (a == b && b == c) //等边三角形三条边都相等{printf("Equilateral triangle!\n");}else if ((a == b && a != c) || (a == c && a != b) || (b == c && b != a)) //等腰三角形任意两边相等{printf("Isosceles triangle!\n");}else //普通三角形{printf("Ordinary triangle!\n");}}else{printf("Not a triangle!\n");}}return 0;
}

代码验证：

---

static 关键字

static 修饰局部变量

被 static 修饰的局部变量称之为静态局部变量

代码演示：

void test()
{static int a = 5;a++;printf("%d ", a);
}int main()
{for (int i = 0; i < 10; i++){test();}printf("\n");return 0;
}

对 test 函数内部定义的局部变量 a 进行了 static 修饰，此时的 a 就是静态局部变量

如果忽略 static 修饰的话，那么程序运行的结果就是 10 个 5，但是加上了 static 修饰，结果就会不同

代码验证：

可以看到，并没有每次进入 test 函数时都重新给变量 a 初始化，而是延续了上次递增的值

原因是因为变量 a 所存储的区域被 static 改变了，从栈区转换到了静态区

在 C语言 学习的时候，可以把内存大概划分为栈区、堆区、静态区

示意图：

所以 static 修饰局部变量改变了变量的存储位置，使得这个静态变量的生命周期延长了，直到程序结束时这个变量的生命周期才结束

static 修饰全局变量

被 static 修饰的全局变量称之为静全局部变量

add.c 文件代码演示：

static int val = 2025;

test.c 文件代码演示： 

extern int val;int main()
{printf("%d", val);return 0;
}

在 add.c 文件中定义了一个全局变量，并且在 test.c 文件中用 extern 关键字声明了 val 变量

如果忽略 static 关键字的话，在 test.c 中能够正常运行代码，因为任何一个全局变量都具有外部链接属性

但是全局变量 val 被 static 修饰后，val 变量就没有了外部链接属性，static 把 val 变量的外部链接属性转换为了内部链接属性，所以 val 变量只能在它所处的 add.c 文件内部使用 

static 修饰函数

被 static 修饰的函数称之为静态函数，被修饰后的作用和 static 修饰全局变量后的作用相似

add.c 代码演示：

static int Add(int x, int y)
{return x + y;
}

test.c 代码演示：

extern int Add(int x, int y);int main()
{printf("%d\n", Add(5, 3));return 0;
}

Add 函数被 static 修饰后，同样把 Add 函数的外部链接属性转换为了内部链接属性

并且 Add 函数只能在 add.c 文件内部使用，其他任何 .c 文件都不能使用了

---

认识指针

指针是来管理内存的，通常使用指针来存放变量的地址

理解指针

代码演示：

int a = 10;int* pa = &a;

& 操作符的作用于取地址，&a 就是取出变量 a 的地址

pa 的类型是 int* ，* 的意思是表明 pa 是指针变量，用来存放指针的，int 的意思是表明所要存放地址的数据类型

当变量 a 的地址存放到了 pa 中后，就可以利用 * 解引用来操作变量 a

代码演示：

*pa = 100;

*pa 可以理解为通过 pa 所存放的地址找到变量 a，再对 a 重新赋值

代码验证：

实际例子

写一个函数，交换两个整数的值

代码演示：

void swap(int* x, int* y)
{int tmp = *x;*x = *y;*y = tmp;
}
int main()
{int a = 3;int b = 5;swap(&a, &b);printf("a = %d, b = %d\n", a, b);return 0;
}

因为形参和实参是各自独立的空间，所以只有把 a 和 b 的地址传递给 swap 函数，才能改变 a 和 b 的值

代码验证：

指针变量的大小

因为指针是用来存放地址的，所以不论是什么类型的指针，在不同的平台下都是固定的

在 32 位平台下：

在 64 位平台下：