C语言基础

1. # 数据类型

   符号	名称	大小 / 字节
   char	字符串类型，结尾默认隐藏一个 \0 转义符，是字符串结束标识	1
   int	整型	4
   short	短整型	2
   long	长整型	4
   long long	超长整型	8
   double	双精度浮点型	8
   float	单精度浮点型	4

2. # 转义字符

   符号	含义
   \' 或 \"	表示字符串内部的单引号或者双引号
   \\	表示反斜杠
   \n	换行
   \r	回车
   \a	警告符，蜂鸣
   \f	进纸符
   \b	退格符
   \t	水平制表符
   \v	垂直制表符
   \ddd	ddd 表示 1-3 个八进制的数字，例：\180
   \xdd	dd 表示 2 个十六进制的数字，例：\x80

3. # 作用域

   • # 全局作用域：可以在整个工程使用。同一个工程不同文件，需要先用 extern 声明一下，才可使用。

     	#include <stdio.h>
     	extern glb_v;
     	int main() {
     	printf("%d", glb_v);
     	return 0;
     	}

   • # 局部作用域：只在括号内部才可以用，括号外引用会报错

     	#include <stdio.h>
     	extern glb_v;
     	int main() {
     	int value1 = 100;
     	{
     	int value2 = 200;
     	}
     	printf("结果：%d %d", value1, value2); //value2 会报错
     	return 0;
     	}

4. # 一些简单的库函数

   • IO 函数：printf、scanf、getchar、putchar 等
   • 文件操作函数：fputc、fgetc、fgets、fopen、fread、fwrite 等
   • 字符串操作函数：strcmp、strlen、strstr 等
   • 字符操作函数：toupper、
   • 内存操作函数：memcpy、memcmp、memset、memmove、malloc 等
   • 时间 / 日期函数：time、mktime、ctime、localtime 等
   • 数学函数：abs、floor、fmod 等
   • 其他函数

   • # 标准库函数

     • # <ctype.h>

     • # <math.h>

     • # <stdio.h>

     • # <stdlib.h>

     • # <time.h>

     • # <string.h>

   • # 部分函数代码用例：

     • # printf ：打印函数

       	#include <stdio.h>
       	int main(){
       	printf("%d\n", 100); // % d 整型，% u 无符号整型，% f 浮点型，% lf 双精度浮点型，% s 字符串，% c 打印对应 ascii 码字符，% p 打印地址
       	printf("Hello World!\n");
       	}

     • # scanf ：输入函数，

       	#define _CRT_SECURE_NO_WARNINGS 1 // 不加这句话，用 visual studio 编译会报错，因为 vs 自己提供了一个 scanf_s, 但是只能 vs 编译器才行，所以不建议用 scanf_s
       	#include <stdio.h>
       	int main(){
       	int a,b;
       	printf("请输入两个整数：\n");
       	scanf("%d %d", &a, &b);
       	}

     • # strlen ：获取字符串长度

       	#include <string.h> // 引入头文件
       	#include <stdio.h>
       	int main(){
       	char a = "abcd";
       	printf("%d\n", strlen(a)); // 如果字符串没有 \0 结束符，则长度返回随机值
       	return 0;
       	}

     • # getcahr ：从标准输入获取一个字符，返回 int 类型，返回的是 ascii 码

       	int a = 0;
       	a = getchar(); // 等待输入
       	printf("%c\n", a);

     • # putchar ：输出字符

       	int a = 0;
       	a = getchar(); // 等待输入
       	putchar(a); // 打印到 dos

     • # sleep ：睡眠函数，单位毫秒

       	#include <windows.h> // 引入头文件
       	int main(){
       	printf("!!!");
       	sleep(1000) // 睡眠 1 秒
       	printf("!!!");
       	return 0;
       	}

     • # system ：执行 dos 命令，返回 int 类型，-1: 出现错误  ，0: 调用成功但是没有出现子进程，大于 0: 成功退出的子进程的 id

       system("cls") // 清除屏幕

     • # strcmp ：字符串比较，返回 int 类型，0: 相等，其他值：不相等

       strcmp("aaa", "aaa"); // 相等返回 0

     • # rand ：返回一个 0-32767 的随机数

       	#include <stdlib.h>
       	#include <time.h>
       	int main(){
       	srand((unsigned int)time(NULL)); // 获取随机数，需要先调用 srand 设置起点，传个随机数，一般用时间戳强转类型
       	int a = rand(); // 随机生成 0-32767，对 100 求余，就获取 0-99 的值
       	printf("%d\n", a);
       	}

     • # time ：返回时间戳

       	#include <time.h>
       	int main(){
       	printf("%d\n", time(NULL));
       	}

5. # 常量与变量

   • # 常量：不可变

     	#include <stdio.h>
     	#define AAA = 1000;
     	int main() {
     	// 1. 字面常量
     	1234; // 数字常量
     	3.14; // 浮点数常量
     	"abcd"; // 字符串常量
     	// 2. const 修饰常量
     	const int aaa = 10; //const 修饰的常变量，本质还是变量，只是具有不可变的属性
     	aaa = 20; //const 修饰的， 重新赋值会报错
     	// 3. #define 定义的标识符常量
     	AAA = 20; // #define 定义的常量不可变，重新赋值会报错
     	// 4. 枚举常量
     	enum Sex{
     	male, // 默认等于 1，下面常量依次递增
     	female
     	}
     	printf("%d\n", male); // 输出 1
     	male = 2; //enum 定义的枚举常量不可变，重新赋值不报错
     	return 0;
     	}

   • # 变量：可变

     	int b = 20; // 变量
     	b = 30; // 可以重新赋值

6. # 条件语句

   • # if 分支语句

     	int a = 1;
     	if(a){ // 中括号可以省略
     	printf("%d\n", a);
     	}else{
     	printf("条件不成立\n");
     	}

   • # switch 分支语句

     	int a;
     	switch a; // 整型常量
     	case 1: // 整型常量表达式
     	print("a:1\n");
     	break;
     	case 2:
     	print("a:2\n");
     	break;
     	default: // 处理错误分支
     	printf("分支错误");
     	break;

   • # while 循环语句

     	int a = 100;
     	while (a > 200){
     	printf("a大于200");
     	a++;
     	if (a <= 50){
     	continue;
     	}else{
     	break; // t
     	}
     	}

   • # for 循环语句

     	int i;
     	for(i=0;i<10;i++) //c++ 可以写成 for (int i=0;i<10;i++)
     	{
     	printf("%d\n", i); // 可以根据业务逻辑增加 break 和 continue 语句
     	}

   • # do...while 循环

     	int i = 0;
     	do // 先执行循环体，再进行判断和 while 语句相反。
     	{
     	printf("%d\n", i);
     	i++;
     	}while(i< 10);

7. # 操作符

   • 算术操作符： + 、 - 、 * 、 / 、 %

   • 移位操作符： << 、 >> 、 & 、 | 、 ^

   • 赋值操作符： = 、 += 、 -= 、 *= 、 /= 、 &= 、 ^= 、 |= 、 >>= 、 <<=

   • 单目操作符：

     [正整数原码，补码，反码相同；负数反码 = 原码除符号位不变，其他按位取反；负数补码 = 反码 + 1]]

     !：逻辑反操作

     -：负值

     +：正值

     &：取地址

     sizeof：操作数的类型长度，以字节为单位

     ~：对一个数的二进制按位取反。

     --：前置 (先 -- 再使用)、后置 (先使用再 --)

     ：前置 (先再使用)、后置 (先使用再 ++)

     *：间接访问操作符（解引用操作符）

     （类型）：强制类型转换

   • 关系操作符：>、<、==、!=、&&、||

   • 三目操作符 (条件表达式):

     a ? b : c // 等价于 if (a){b} else {c};

8. # 常见关键字

   auto 、 assert 、 break 、 switch 、 case 、 char 、 const 、 continue 、 default 、 do 、 double 、 else 、 enum 、 extern 、 float 、 for 、 goto 、 if 、 int 、 long 、 register 、 return 、 short 、 signed 、 sizeof 、 static 、 struct 、 typedef 、 union 、 unsigned 、 void 、 volatile 、 while

   部分关键字：

   auto：每个局部变量都由 auto 修饰，自动创建，自动释放。

   extern：用来声明外部符号。

   register：寄存器关键字，频繁使用的数据，想放在寄存器中提升效率。

   typedef：类型重命名

   static：静态修饰符。修饰局部变量，改变了局部变量的生命周期；修饰全局变量，使得此全局变量只能在自己所在的原文件使用。

9. # struct：结构体

   	struct student{
   	char name[20];
   	int age;
   	float score;
   	};
   	int main(){
   	struct student s = {"张三", 18, 90.5}; // 结构体创建
   	printf("1：%s %d %lf\n", s.name, s.age, s.score); // 结构体变量。成员变量
   	struct student * ps = &s;
   	printf("2：%s %d %lf\n", (*ps).name, (*ps).age, (*ps).score);
   	printf("3：%s %d %lf\n", ps->name, ps->age, ps->score); //-> 左边指针，右边成员变量
   	return 0;
   	}

10. # 指针：内存中的偏移地址

    	int main(){
    	int a = 10;
    	printf("%p\n", &a); // &a 取变量 a 的指针，% p 用来打印地址
    	int *pa = &a; // * 表示 pa 是指针变量，用来存放地址；int 表示 pa 执行的对象是 int 类型
    	*pa = 20; // 解引用，*pa 就是通过地址找到 a，给 a 赋值
    	char b = 'bb';
    	char *pb = &b;
    	return 0;
    	}

    • # 指针大小在 32 位平台是 4 个字节，在 64 位平台是 8 个字节。

    • # 指针类型：决定了指针解引用的权限有多大，以下三个案例表示指针类型的意义

      	int main(){
      	int a = 0x 11223344; //a 在内存中值为 44 33 22 11
      	int *pa = 0; //a 在内存中值变成 00 00 00 00
      	char *pb = 0; //a 在内存中的值变成 00 33 22 11
      	return 0;
      	}

      	int main(){
      	int arr[10] = {0}; // 假设地址为 0x427865b8
      	int *p = &arr;
      	char *pb = &arr;
      	printf("%p\n", p); // 0x427865b8
      	printf("%p\n", pb); // 0x427865b8
      	printf("%p\n", p + 1); // 加 1 变成 0x427865bc
      	printf("%p\n", pb + 1); // 加 1 变成 0x427865b9
      	return 0;
      	}

      	int main(){
      	int arr[10] = {0};
      	int *p = &arr; //int 类型时，p+1 代表一个数组的元素，4 个字节；char 类型时，p+1 代表一个字节
      	for(int i=0;i < 10; i++){
      	*(p + 1) = 1;
      	}
      	return 0;
      	}

    • # 二级指针：一级指针的地址

      	int main(){
      	int a = 10;
      	int *pa = &a; //pa 是指针变量，是一级指针
      	int **ppa = &pa; // &pa 取出 pa 在内存中的起始地址，存放到 ppa 中，是二级指针
      	return 0;
      	}

​