[大数据]C语言学习笔记

计算机相关

系统组成

1. 硬件系统
   1. 主机
      1. 中央处理器（CPU）
         1. 寄存器
         2. 运算器
         3. 控制器
      2. 内存储器
         1. 随机存储器（RAM）
         2. 只读存储器（ROM）
   2. 外部设备（外设）
      1. 输入设备：鼠标、键盘、摄像头等
      2. 输出设备：声卡、显卡等
      3. 外存储器：光盘、硬盘、U盘等
2. 软件系统
   1. 系统软件
      1. 操作系统
      2. 语言处理系统
      3. 数据库管理系统
      4. 系统服务程序
   2. 应用软件

内存储器与外存储器

• 内存储器

采用电信号存储数据，速度快，但是断点数据丢失

• 外存储器

如光盘，采用磁信号存储数据，速度慢，但是可以用来做数据持久化

数据计算时的存储变化

如一个磁盘中的数据：
磁盘 > 磁盘缓存 > 内存 > CPU缓存 > 寄存器 > 运算

寄存器

几个概念

1. 寄存器是CPU内部的最基本的存储单元
2. CPU通过总线（数据、地址、控制）来和外部设备打交道
3. 如果CPU的总线是8位，寄存器也是8位，则这就是个8位的CPU；倘若总线16位，寄存器32位，那么则是一个准32位CPU
4. 在64位的CPU上运行64位的操作系统，则这是个64位的操作系统，若运行的是32位的操作系统，则这是个32位的操作系统
5. 64位的软件不能运行在32位的CPU上

寄存器名称

对寄存器的操作

C语言对寄存器做了封装，只能做些简单的操作，如果想进行更深层次的操作，需要使用汇编语言，对此，可以在C语言中嵌套编写汇编语言

#include <stdio.h>

int main(void)
{
	int a, b, c;
	__asm
	{
		mov a, 3 //将3放在a对应的内存中
		mov b, 4 //将4放在b对应的内存中
		mov eax, a //将a放入寄存器中
		add eax, b //将b放入寄存器中，并和其中的a进行加法运算，运算结果（7）依旧在寄存器中
		mov c, eax //将寄存器中的运算结果放入c对应的内存中
	}
	printf("c: %d\n", c); //7
	system("pause");
	return 0;
}

Visual Studio相关

VS执行程序时窗口闪退问题的解决方案

1. 通过system函数

#include <stdio.h>

int main(void)
{
	printf("hello world\n");
	system("pause");
	return 0;
}

2. 通过修改VS配置

右键项目 > 属性 > 配置属性 > 链接器 > 系统 > 子系统：控制台

代码片段管理

1. 新建一个，如main函数的

<!--c模板-->
<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2019/CodeSnippet">
	<CodeSnippet Format="1.0.0">
		<Header>
			<Title>#1</Title>
			<Shortcut>#1</Shortcut>
			<Description>c语言main函数</Description>
			<Author>Microsoft Corporation</Author>
			<SnippetTypes>
				<SnippetType>Expansion</SnippetType>
				<SnippetType>SurroundsWith</SnippetType>
			</SnippetTypes>
		</Header>
		<Snippet>
			<Declarations>
				<Literal>
					<ID>expression</ID>
					<ToolTip>要计算的表达式</ToolTip>
					<Default>true</Default>
				</Literal>
			</Declarations>
			<Code Language="cpp"><![CDATA[#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <Windows.h>

int main(void)
{
	$selected$$end$
	system("pause");
	return EXIT_SUCCESS;
}
					]]>
			</Code>
		</Snippet>
	</CodeSnippet>
</CodeSnippets>

<!--c++模板-->
<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2019/CodeSnippet">
	<CodeSnippet Format="1.0.0">
		<Header>
			<Title>#2</Title>
			<Shortcut>#2</Shortcut>
			<Description>c++语言main函数</Description>
			<Author>Microsoft Corporation</Author>
			<SnippetTypes>
				<SnippetType>Expansion</SnippetType>
				<SnippetType>SurroundsWith</SnippetType>
			</SnippetTypes>
		</Header>
		<Snippet>
			<Declarations>
				<Literal>
					<ID>expression</ID>
					<ToolTip>要计算的表达式</ToolTip>
					<Default>true</Default>
				</Literal>
			</Declarations>
			<Code Language="cpp"><![CDATA[#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

int main()
{
	
	$selected$$end$

	system("pause");
	return EXIT_SUCCESS;
}]]>
			</Code>
		</Snippet>
	</CodeSnippet>
</CodeSnippets>

2. 导入

工具 -> 代码片段管理 -> Visual C++

几个常用快捷键

1. 格式化代码

ctrl k + ctrl f

2. 注释

ctrl k + ctrl c

3. 去除注释

ctrl k + ctrl u

4. 只编译不运行

ctrl shift b

GCC编译的四个步骤

记事本创建hello.c

#include <stdio.h>

#define PI 3.14159

int main(void)
{
    int a = 1;
    #ifdef PI //判断某个宏是否被定义，若已定义，执行随后的语句
    printf("PI: %f\n", PI);
    #endif
    printf("hello c\n");
    return 0;
}

步骤一：预处理

1. 参数：-E
2. 命令：gcc -E hello.c -o hello.i
3. -o 选项：表示重命名
4. 主要工作

1. 展开头文件

即，会将所有引入的头文件，如此例中的<stdio.h>中的stdio.h文件进行展开，需要注意的是，只是展开但是不会对头文件进行检查和校验，即写成<test.txt>也一样会将text.txt进行展开。

gcc -E hello.c -o hello.i -I . //需要使用 -I 选项指定test.txt的所在路径

2. 展开条件编译

即，在此步骤中，条件编译#ifdef部分代码会被展开执行

#ifdef PI
printf("PI: %f\n", PI); 
#endif

执行后的 hello.i

printf("PI: %f\n", PI); 

3. 替换注释

即，在此步骤中，无论单行注释还是多行注释，都会被替换为空白行

4. 替换宏定义

即，在此步骤中，宏定义会执行替换工作，如例中的宏变量PI，会被替换为其宏值3.14159

//hello.i
printf("PI: %f\n", 3.14159);

步骤二：编译

1. 参数：-S
2. 命令：gcc -S hello.i -o hello.s
3. 主要工作

1. 会逐行检查语法，也因此编译过程是最为耗时的过程
2. 将C语言转换成汇编指令

步骤三：汇编

1. 参数：-c
2. 命令：gcc -c hello.s -o hello.o
3. 主要工作：将汇编指令翻译为机器码（二进制编码）

步骤四：链接

1. 参数：无
2. 命令：

gcc hello.o -o hello.exe //windows系统
gcc hello.o -o hello //linux系统，之后 ./hello 即可调用执行

3. 主要工作

1. 数据段合并
2. 数据地址回填
3. 库引入

即除了头文件外，还需要引入许多其他系统库，可以使用depends.exe查看所引入的库（将hello.exe拖入其中即可）

常量与变量

常量的定义

/*
方式一：宏定义
#define：表示进行宏定义
宏名：PI
宏值：3.1415926
注意：无封号，也无需类型关键字
*/
#define PI 3.1415926

/*
方式二：const关键字
const关键字：所修饰的变量只读，相当于就是个常量
注意：不推荐用这种方式来创建常量
*/
const int a = 1;

变量的定义

/*变量类型 变量名 = 变量值*/
int var = 1;

变量的声明

/*
方式一：没有变量值的定义为变量的声明
*/
int var;

/*
方式二：extern关键字
*/
extern int a;

/*
两种方式的区别
  对应一个变量，在使用之前必须要进行定义，如果只是声明而为定义，
  则C也会自行将该声明提升为定义，即会赋予一个默认值，
  如果该变量是全局变量，则赋予值0，
  否则如果是linux则赋予一个随机数，如果是windows则直接编译出错；
  而extern的特别之处就在于，用了该关键字后，变量声明无法被提升为定义。
*/

#include <stdio.h>
int a;
int main(void)
{
	printf("a: %d\n", a); //0
	return 0;
}

#include <stdio.h>

int main(void)
{
    int a;
	printf("a: %d\n", a); //windows下直接编译出错
	return 0;
}

#include <stdio.h>
extern int a;
int main(void)
{
	printf("a: %d\n", a); //报错，因为extern修饰后无法被提升
	return 0;
}

数据类型

整形

几种整形

1. short：2字节
2. int：4字节
3. long：windows下4字节；linux下32位系统为4字节，64位为8字节
4. long long：8字节

有符号与无符号

1. 关键字

1. signed：有符号

默认就是有符号，所以通常省略不写

2. unsigned：无符号

即存储的字节中无符号位

2. 字节数

有符号和无符号的字节数一样

其他几个常用类型

字符类型

1. 关键字：char
2. 字节数：1
3. 常见字符与其对应的数值

4. char的取值范围
   1. 规定

   00000000: 0; 10000000: -128
   

   2. 有符号

   -2^(8-1) ~ 2^(8-1) - 1; // -128 ~ 127 减1是因为从0开始
   

   3. 无符号

   0 ~ -2^(8) - 1; // 0 ~ 255 减1是因为从0开始
   

浮点类型

1. 字节数
   1. float：4
   2. double：8
2. 注意
   float f = 1.1f; //需要加上f后缀，否则默认视为double类型

字符串类型

• 说明

在C语言中，字符串类型有个很重要的特点，就是\0，这是字符串的结束标记，且对于用户设置的字符串，系统会自动添加该字符，如定义的 “abc”，实质上是4个字符，即"abc\0"

printf("ab\0c"); //ab，当遇到第一个\0时，停止打印

/*printf的特性：例子中ab后输出一堆乱码，原因是printf没有遇到\0，所以会一直向后打印，直到遇到为止*/
char str[2] = { 'a', 'b' };
printf("str: %s\d", str); //str: ab烫烫烫烫烫d

字符串相当于是字符数组的一个特殊形式，即必须以’\0’结尾

• 定义

/*方式一：使用字符数组来定义，需要手动填写'\0'字符串结束符*/
int str[6] = {'h', 'e', 'l', 'l', 'o', '\0'}; // 如果此处元素个数设置为7个，则第七个元素，即未赋值的元素，默认值为'\0'

/*方式二*/
int str[] = "hello"; //默认就有'\0'

/*定义一个全是'\0'的字符数组*/
char str[6] = {0};

• 接收

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main(void)
{
	char str1[6] = { 0 };

	/*方式一*/
	scanf("%s", str1);
	printf("res1: %s\n", str1); //hello

	char str2[6] = { 0 };
	/*方式二*/
	for (size_t i = 0; i < sizeof(str1) / sizeof(str1[0]); i++)
	{
		scanf("%c", &str2[i]);
	}
	printf("res2: %s\n", str1); //hello
	return 0;
}

• 方法

• gets & fgets

int main(void)
{
	/*
	char *gets(char *str)
	1. 说明：读取整行输入（可以接收空格），直至遇到换行符，然后丢弃换行符，储存其余字符，并在其末尾添加一个空字符使其成为一个字符串。
	2. 问题：gets和scanf一样，未进行检查，所以存在越界问题，即有多少字符它就给你输入多少，所以有可能擦掉程序中的其他数据，对此也有gets_s函数
	3. 返回值：char *，返回一个字符串的首地址，即实际获取到的字符串
	4. 参数str：用来存储字符串的空间
	*/
	char str1[10]; //char str1[11] = {0}; 这样才不会越界
	//gets(str);
	gets_s(str1, 11);
	printf("str1 = %s\n", str1); //helloworld

	/*
	char *fgets(char *str, int size, FILE *stream)
	1. 说明：作用同gets，但是不存在溢出问题，另外会预留'\0'的位置，还有对于最后输入的\n，当空间充足时会读取，否则会舍弃
	2. 返回值：同gets
	3. 参数str：同gets
	4. 参数size：存储空间大小，同gets_s的第二个参数
	5. 参数stream：读取字符串的位置（如可以输入文件路径），键盘为标准输入stdin
	*/
	char str2[11];
	printf("str2 = %s\n", fgets(str2, sizeof(str2), stdin)); //helloworld
	return 0;
}

• puts & fputs

int main(void)
{
	/*
	int puts(const char *str)
	1. 说明，和get（读取）相反，是用于将字符串写出到屏幕，另外会自动在最后输出\n
	2. 返回值：是否写入成功，-1表示失败，成功为一个非负数（一般用0表示）
	3. 参数str：待写出的字符串
	*/
	char str[] = "hello world";
	int ret1 = puts(str);
	printf("ret1 = %d\n", ret1);

	/*
	int fputs(const char *str, FILE *stream)
	1. stream：可以指定写出的位置，默认为屏幕，即标准输出stdout
	2. 区别：不会自动输出\n
	*/
	int ret2 = fputs(str, stdout);
	printf("ret2 = %d", ret2);
	return 0;
}

• strlen

int main(void)
{
	/*
	size_t strlen(const char *str)
	1. 说明：用于获取字符串的有效长度，不包含'\0'
	2. 头文件：<string.h>
	3. size_t：unsigned int
	*/
	char str1[] = "hello world";
	printf("sizeof: %u\n", sizeof(str1)); //12
	printf("strlen: %u\n", strlen(str1)); //11
	char str2[] = "hello\0world";
	printf("sizeof: %u\n", sizeof(str2)); //12
	printf("strlen: %u\n", strlen(str2)); //5
	return 0;
}

sizeof & printf

sizeof

1. 不是个函数，无需引入头文件，作为一个关键字，用于计算一个数据类型的字节大小
   
2. 返回值类型为size_t，通过typedef对unsigned int起的一个别名
3. 如果传入的是变量值，则括号可以省略

printf

示例

#include <stdio.h>
extern int a;
int main(void)
{
	short s = 2;
	int i = 4;
	long l = 8; // or 8L
	long long ll = 8; // or 8LL
	unsigned short us = 2; // or 2u
	unsigned int ui = 4; // or 4u
	unsigned long ul = 8; // or 8Lu
	unsigned long long ull = 8; // or 8LLU

	printf("short: %u\n", sizeof s); // 2
	printf("int: %u\n", sizeof(int)); // 4
	printf("long: %u\n", sizeof(long)); // 4
	printf("long long: %u\n", sizeof(long long)); // 8
	printf("unsigned short: %u\n", sizeof(unsigned short)); // 2
	printf("unsigned int: %u\n", sizeof(unsigned int)); // 4
	printf("unsigned long: %u\n", sizeof(unsigned long)); // 4
	printf("unsigned long long: %u\n", sizeof(unsigned long long)); // 8

	return 0;
}

类型限定符

extern

表示 变量/函数 声明，用该关键字声明后的 变量/函数 将不会自动创建内存存储空间

volatile

用于阻止编译器自行优化代码

volatile int flag = 0;
flag = 1; //1
flag = 0; //2
flag = 1; //3
flag = 0; //最后依旧是flag=0，对于这种情况，编译器会进行代码优化，会删除中间变化，即1,2,3步的代码会被删除，而使用了volatile后将不会删除

const

见常量的定义

register

定义一个寄存器变量，即用该关键字定义的变量，将直接存放到寄存器中，但要注意的是不一定保证每次都存放成功，如寄存器已满的情况下将存放失败

寄存器没有和内存一样的地址的概念

int a = 5; //默认将a放入内存中
a + 10; //当使用a时，会先将a放入寄存器中，然后开始执行相关运算

数值存储方式

存储方式

计算机内部以补码的方式存储一个数值

原码

• 特点

1. 最高位作为符号位，0正1负
2. 其他部分为该数值本身绝对值的二进制表示

• 示例

数值	原码
15	00001111
-15	10001111
0	00000000
-0	10000000

反码

• 特点

1. 正数的反码同原码
2. 负数的反码为原码符号位不变，其他位置取反

• 示例

数值	反码
15	00001111
-15	11110000
0	00000000
-0	11111111

补码

• 特点

1. 正数的补码同原码
2. 负数的补码为反码符号位不变，加 1

• 根据补码求原码

1. 符号位不变，补码 - 1，然后取反
2. 符号位不变，取反，再加 1

• 示例

数值	反码
15	00001111
-15	11110001
0	00000000
-0	10000000

示例：43 - 27

+43的补码：00101011
-27的原码：10011011
-27的反码：11100100
-27的补码：11100101

00101011
11100101
——————
00010000 = 16

数据溢出

符号位溢出

• 说明

对于有符号的数值可能发生，发生后数值的正负符号将改变

• 示例

char c = 127 + 1;
01111111
00000001
-------------
10000000(补码)
11111111(反码)
10000000(原码) = -128

最高位溢出

• 说明

对于无符号的数值可能发生，由于最高位丢失，所以发生后数值的差异可能十分大

• 示例

unsigned char c = 255 + 1;
11111111
00000001
--------------
100000000 -> 溢出后：00000000 = 0

运算符

算数运算符

同java

赋值运算符

同java

比较运算符

同java

逻辑运算符

同java

• 注意

c中 0、’\0’ 也表示false

	    int aa = 0;
		if (!aa) 
		{
			printf("aa0 = %d", aa);
		}
		else 
		{
			printf("aa1 = %d", aa);
		}
		//aa0 = 0

三目运算符

同java

逗号运算符

int a = 10, b, c = 30;
int x = (a = 100, b = a * 2, c = c * 10 + a + b);
printf("a = %d\n", a); //100
printf("b = %d\n", b); //200
printf("c = %d\n", c); //600
printf("x = %d\n", x); //600，取最后一个结果
return 0;

类型转换

隐式类型转换

注意：如 float、int 进行运算时，都转为链中的交点，即double

强制类型转换

同java

分支语句

同java

循环语句

同java

数组

1. 相同数据类型的有序（地址）集合
2. 数组名为第一个元素的地址
3. 数组空间大小为所有元素大小之和

#include <stdio.h>


int main(void)
{
	int arr[5] = { 4, 6, 1, 2, 90 };
    printf("arr = %x\n", arr);
	printf("&arr[0] = %x\n", &arr[0]); //   地址为16进制，所以可以用%x来输出打印
	printf("&arr[1] = %x\n", &arr[1]); //   
	printf("&arr[2] = %p\n", &arr[2]); //   %p为地址的格式匹配符
	printf("&arr[3] = %p\n", &arr[3]); //   地址为16进制，所以可以用%x来输出打印
	printf("&arr[4] = %p\n", &arr[4]); //   地址为16进制，所以可以用%x来输出打印
	printf("数组元素大小：%u\n", sizeof(int)); //4
	printf("数组大小：%u\n", sizeof(arr)); //20，即 (4 * 5)
	/*
   arr = 10ffc48
	&arr[0] = 10ffc48
	&arr[1] = 10ffc4c
	&arr[2] = 010FFC50
	&arr[3] = 010FFC54
	&arr[4] = 010FFC58
	可见，彼此相隔4字节，是连续的地址
	*/
	return 0;						      
}

4. 初始化一个全为0的数组，需要设置至少一个0元素，否则将是随机数

int arr1[10]; //生成的是10个随机数
int arr2[10] = {0}; //生成全为0的数组，即同java一样，未设置的元素默认值为0
int arr3[3][5] = {0}; //多维数组也一样

//注意
int arr[10];
arr[0] = 1;
//这样做，arr[1 ~9]依旧是个随机数，不是0，因为在声明时已经赋予了初始随机默认值

5. 可以不指定个数，即数组可以自己计算元素个数

int arr[] = {1, 2, 3}; //会自动统计元素个数 - 3

函数

函数声明

返回值类型 函数名(形参列表); //这就是函数声明

隐式函数声明

/*
1. 在 c 语言中，在调用一个函数之前，必须先有该函数的定义，
2. 如果没有则必须有函数声明，如果依旧没有，则编译器自动为该函数添加一个隐式的函数声明
3. 只不过隐式声明的函数返回值，均为 int 类型
*/

函数声明案例

1. 函数调用前有函数定义：可以正常调用

#include <stdio.h>

void add(int a, int b) 
{
	printf("a + b = %d", a + b); //a + b = 3
}
int main(void)
{
	add(1, 2);
	return 0;
}

2. 函数调用前无函数定义：自动隐式声明

如果函数恰好返回值为int，则正常调用，否则将抛出重复声明定义的错误

3. 函数调用前无函数定义，但是有函数声明：可以正常调用

#include <stdio.h>

void add(int a, int b); //函数声明

int main(void)
{
	add(1, 2);
	return 0;
}

void add(int a, int b)
{
	printf("a + b = %d", a + b); //a + b = 3
}

exit函数

1. 头文件

stdlib

2. exit()

退出当前程序

3. return

底层实质上在调用_exit()方法

main函数

不带参的main函数

• 语法

//写法一
int main(void);

//写法二
int main();

带参的main函数

• 语法

//写法一
int main(int argc, char * argv[]);

//写法二
int main(int argc, char ** argv);

/*
argc: 传递的参数的个数 
argv: 指针数组，其中数组的每个元素为char *，即字符串
 */

• 测试

#include<stdio.h>

int main(int argc, char* argv[])
{
	for (size_t i = 0; i < argc; i++)
	{
		printf("argv[%d] = %s\n", i, argv[i]); //test.exe aa bb cc dd ee，即至少有一个参数：argv[0] = 程序的相对路径.exe
	}
	return 0;
}

• 测试一：使用gcc

1. gcc test.c -o test.exe
2. test.exe aa bb cc dd ee

• 测试二：利用vs

右键项目 -> 属性 -> 调试 -> 命令参数

函数与指针

• 栈帧

当函数调用时，系统会在stack空间中申请一块栈帧内存区域，可以存放形参与局部变量，以用来提供函数调用


当函数调用时，这块栈帧内存区域也会被自动释放

• 传值

• 传递非地址

#include<stdio.h>

/*
1.在stack中开辟main栈帧，存储局部变量m和n
2.在stack中，挨着main再创建一个swap栈帧，存储形参a和b，再存储局部变量tmp
3.swap中a和b的值交换
4.swap结束，对应栈帧释放
5.输出m和n，依旧是原来的值
*/

void swap(int, int);

int main(void)
{
	int m = 1; 
	int n = 2;
	printf("m = %d, n = %d\n", m, n); //m = 1, n = 2
	swap(m, n);
	printf("m = %d, n = %d\n", m, n); //m = 1, n = 2
	return 0;
}

void swap(int a, int b)
{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
}

• 传递地址

#include<stdio.h>

void swap(int* a, int* b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

int main(void)
{
	int m = 1;
	int n = 2;
	printf("m = %d, n = %d\n", m, n); //m = 1, n = 2
	swap(&m, &n);
	printf("m = %d, n = %d\n", m, n); //m = 2, n = 1
	return 0;
}

• 传递数组
  当数组作为参数时，传递给函数的不是整个数组，而是数组的首地址，所以此时在函数中对形参进行sizeof计算，得到的是一个指针的大小，而非整个数组的大小，也因此，当需要传递数组时，通常会额外的添加一个形参，用于接收数组的长度

#include<stdio.h>

//形参也可以指定长度，即int arr[100]，
//形参还可以直接用指针，即int * arr
void bubbleSort(int arr[], int length) 
{
	//printf("sizeof(arr) = %d", sizeof(arr)); //4，求的是一个int类型指针的大小
	int* inner;
	for (size_t i = 0; i < length - 1; i++)
	{
		inner = arr;
		for (size_t j = 0; j < length - i - 1; j++, inner++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp;
				tmp = *inner;
				*inner = *(inner+1);
				*(inner + 1) = tmp;
			}
		}
	}
}

int main(void)
{
	int arr[10] = { 2, 5, 9, 1, 4, 3, 7, 6, 10, 8 };
	int length = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, length);
	for (size_t i = 0; i < length; i++)
	{
		printf("arr[%d] = %d \n", i, arr[i]); // 1 2 3 4 5 6 7 8 9 10
	}
	return 0;
}

• 返回值

• 返回数组

C语言不允许返回数组

• 返回指针

不要返回函数内部的局部变量，因为函数结束后栈帧被释放，其中的局部变量将随时被系统分配到其他地方使用

#include<stdio.h>

int m = 10000;

int* ret_point_test()
{
	/*
	不要直接返回局部变量
	int a = 100;
	return &a;
	*/
	return &m;
}

int main(void)
{
	int* p;
	p = ret_point_test();
	printf("p = %d\n", *p); //10000，如果返回的是局部变量a，输出的可能是100，那是因为ret_point_test对应的栈帧结束并被标记为释放后，暂时没有被系统分配给其他地方使用
	return 0;
}

多文件编程

• 含义

将多个含有不同功能.c文件模块，编译到一起，生成一个可执行文件

• 源文件/add.c

int add(int a, int b)
{
	return a + b;
}

• 头文件/demo.h

1. 头文件守卫

用于防止同一头文件在单个CPP/C文件中被重复分析

//方式一：仅在windows系统中可以使用
#pargma once

//方式二：通用方法
#ifndef __DEMO_H__ //对应demo.h
#define __DEMO_H__
    //头文件内容
#endif

2. 头文件内容

/*
常用内容如下：
1. 头文件引入，如 #include <stdio.h>
2. 函数声明
3. 类型定义
4. 宏定义
 */

#ifndef __DEMO_H__
#define __DEMO_H__
//引入头文件
#include <stdio.h>
//函数声明
int add(int a, int b);
//类型定义
//宏定义
#endif

• 源文件/main.c

#include "demo.h" //自定义头文件的引入用""，在预处理时将会被展开

int main(void)
{
	int res = add(1, 2);
	printf("1 + 2 = %d", res);
	return 0;
}

指针

指针和内存单元

1. 指针

即内存地址

2. 内存单元

计算机中内存的最小存储单位，大小为一个字节

3. 内存单元与指针的关系

每个内存单元都对应有一个惟一编号，该编号就称为该内存单元的地址

4. 指针变量

即存储指针的变量

指针的定义和使用

• 关于变量在等号左右两边的不同含义

int m = 10; //m在=左边，表示的是变量名，即对应的内存空间
int n = 20;
n = m; //m在=右边，表示的是m所指向的内存空间中的存储的内容，即10

int a = 10;
int *p = &a; //定义一个整形指针变量p，注意也可以写成 int* p 或 int * p
//等价于 int *p; p = &a;
*p = 20; //指针的使用（指针的解引用/简介引用）
printf("a = %d", a); //20
/*
 * 解释
 * 1. 开辟空间，存储变量a，内容为10
 * 2. 开辟空间，存储变量p，内容为a的地址
 * 3. 取出p变量的内容，当做地址看待，并找到地址对应的内存空间（即a的内存空间），此时：
 * 		1. 如果*p为左值（即在等号左边），则将数据（20）存储到内存空间中
 * 		2. 如果是右值，则取出空间中的内容
 */
 int aa = 10;
 int *pp = &aa;
 aa = 20;
 printf("*pp = %d", *pp); //*pp取出aa的内容，所以为20

指针的大小

指针的大小与数据类型无关，只与操作系统位数有关，即32位的系统，指针为4字节；64位操作为8字节

printf("%u\n", sizeof(void*));
printf("%u\n", sizeof(char*));
printf("%u\n", sizeof(short*));
printf("%u\n", sizeof(int*));
printf("%u\n", sizeof(long*));
printf("%u\n", sizeof(long long*));
printf("%u\n", sizeof(float*));
printf("%u\n", sizeof(double*));

野指针与空指针

1. 没有一个有效空间地址的指针称为为野指针

int main(void)
{
	int* p;
	*p = 10000; //将p变量的内容取出当做一个地址看待，但是内容是个随机数，所以会报错
	return 0;
}

2. p，即指针有一个值，但是该值是不可访问的，则此时p也是个野指针

int main(void)
{
	int* p = 10; //定义了一个指针变量p，地址为10，但是【内存地址0-255规定是要留给操作系统使用的，即不可访问】，所以会报错，要注意的是即使不是0-255，指定的数值地址，也不一定是可访问的
	*p = 10000;
	return 0;
}

3. 杜绝使用野指针 – 空指针

int main(void)
{
	int* p = NULL; //此时p为定义的一个空指针【NULL = (void *)0，即0地址 --> 是不可访问的】
    //...
	if (p != NULL)
	{
		*p = 10000;
	}
	return 0;
}

泛型指针

可以接收任意一种变量地址，但是在使用的时候必须进行强制类型转换，转换为对应的数据类型

int main(void)
{
	void* p1, * p2;
	int a = 10;
	char ch = 'R';
	p1 = &a;
	p2 = &ch;
	printf("p1 = %d\n", *((int *)p1));
	printf("p2 = %c\n", *((char *)p2));
	return 0;
}

指针和数组

• 数组名是地址常量，即不可被修改
• &arr = arr
• 指针是变量，所以可以用数组名给指针赋值
• 取数组元素的几种方式

int main(void)
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int* p = arr;
	int length = sizeof(arr) / sizeof(arr[0]);
	for (size_t i = 0; i < length; i++)
	{
		//方式一：arr[i]
		printf("方式一：%d\n", arr[i]);
		//方式二：*(arr+i)
		printf("方式二：%d\n", *(arr + i));
		//方式三：p[i]
		printf("方式三：%d\n", p[i]);
		//方式四：*(p+i)
		printf("方式四：%d\n", *(p + i));
	}
	return 0;
}

• 指针和数组的区别

1. 指针是变量，数组名为常量
2. sizeof

sizeof(指针) //4/8
sizeof(数组) //数组的实际字节数

指针与const

• 通过指针的方式可以修改const修饰的变量的值

int main(void)
{
	const int a = 10;
	int *p = &a;
	*p = 20;
	printf("a = %d\n", a); //20
	return 0;
}

• const对指针的几种修饰方式

int main(void)
{
	/*
	1. const int *p
	2. int const *p
	可以修改p变量，但是不能修改*p

	3. int * const p
	不可以修改p变量，但是可以修改*p
	4. const int * const p
	p变量，*p都不可以被修改
	*/
}

• const修饰指针的应用场景

常用语函数形参，如

int fputs(const char * str, FILE * stream);
防止待输出的字符串str被中途篡改

指针类型的作用

如有数据：

int a = 0x12345678;

其在内存的存储情况如下：

1. int类型共占有4个字节，对应四个连续的地址0xff00到0xff03，并以首地址0xff00为变量a地址
2. 一个16进制对应4个二进制位，所以两个16进制数就

78

56

34

12

0xff00

0xff01

0xff02

0xff03

指针类型的作用：

1. 决定了指针从存储地址开始的读取的字节数，如int一次读取4个字节
2. 决定了指针变量做加/减1运算时偏移的字节数，如int一次偏移4个字节

int main(void)
{
	int a = 0x12345678;
	int* p1 = &a;
	short* p2 = &a;
	char* p3 = &a;
	printf("*p1 = %p\n", *p1); //12345678
	printf("*p2 = %p\n", *p2); //00005678
	printf("*p3 = %p\n", *p3); //00000078
    printf("&a = %p\n", &a); //00FF0000
	printf("p1 = %p\n", p1); //00FF0000
	printf("p1 + 1 = %p\n", p1 + 1); //00FF0004
	printf("p2 = %p\n", p2); //00FF0000
	printf("p2 + 1 = %p\n", p2 + 1); //00FF0002
	return 0;
}

int main(void)
{
	int arr[] = {1, 2, 3, 4, 5, 6, 7, 8 ,9};
	int* p = &arr;
	int length = sizeof(arr) / sizeof(arr[0]);
	for (size_t i = 0; i < length; i++, p++)
	{
		printf("arr[%d] = %d\n", i, *p);
	}
	printf("p - arr = %d", p - arr); //9，地址相减得到的是元素的个数
	return 0;
}

指针的算术运算

• 指针与整数的乘除取余操作：error，即无法进行
• 指针与整数的加减操作

1. 普通指针变量的加减

char * p; p + 1; //表示偏移对应的字节数

2. 在数组中的加减

int arr[] = {1, 3, 5};
int *p = arr;
p + 1; //表示偏移的元素个数（本质还是字节数）

• &数组名 + 1

int main(void)
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 ,9 };
	printf("arr      = %p\n", arr);
	printf("&arr[0]  = %p\n", &arr[0]);
	printf("arr + 1  = %p\n", arr + 1);
	printf("&arr[1]  = %p\n", &arr[1]);
	printf("&arr     = %p\n", &arr); //数组首元素地址
	printf("&arr + 1 = %p\n", &arr + 1); //偏移一个数组的大小，即偏移(数组元素个数*sizeof(数组类型))的大小
	/*
	arr      = 006FFA38
	&arr[0]  = 006FFA38
	arr + 1  = 006FFA3C
	&arr[1]  = 006FFA3C
	&arr     = 006FFA38
	&arr + 1 = 006FFA5C
	*/
	return 0;
}

• 指针之间的算术运算

1. 加、乘除、取余：error，即禁止操作
2. 减法

int main(void)
{
	//1.对于普通变量，无实际意义
	int a = 10;
	int b = 20;
	int* pa = &a;
	int* pb = &b;
	printf("pa = %p\n", pa); //012FF77C
	printf("pb = %p\n", pb); //012FF770
	printf("pa - pb = %p\n", pa - pb); //00000003，即 (C-0)/sizeof(int)

	//2.对于数组，相当于二者对应元素的下标之差
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int* p = &arr[3];
	int* q = &arr[6];
	printf("q - p = %d", q - p); //3
	return 0;
}

指针的比较运算

• 地址之间可以进行比较大小（> < =）
• 普通变量的比较没有意义，主要用于数组，可以将地址视为数字，即比较这个数字的大小，大的表示在更高位
• p != NULL，即常用语是否为空指针的比较

指针实现的strlen函数

int mystrlen(const char str[]);

int main(void)
{
	char str[] = "hello world";
	int len = mystrlen(str);
	printf("length is %d\n", len);
	return 0;
}

int mystrlen(const char str[]) {
	char* p = str;
	while(*p != '\0') 
	{
		p++;
	}
	return p - str;
}

指针数组

1. 指针数组本质就是一个二级指针：**arr

int main(void)
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* pa = &a;
	int* pb = &b;
	int* pc = &c;
	int* arr[] = { pa, pb, pc };
	printf("*(arr[0]) = %d\n", *(arr[0])); //10
	printf("*(*(arr + 0)) = %d\n", *(*(arr + 0))); //10
	printf("**arr = %d\n", **arr); //10
	return 0;
}

2. 二维数组本质也是个二级指针

int main(void)
{
	int a[] = { 10 };
	int b[] = { 20 };
	int c[] = { 30 };
	int* arr[] = { a, b, c };
	printf("arr[0][0] = %d\n", arr[0][0]); //10
	printf("*((*(arr + 0) + 0)) = %d\n", *((*(arr + 0) + 0))); //10
	printf("**arr = %d\n", **arr); //10
	return 0;
}

多级指针

int main(void)
{
	int a = 10;
	int* p = &a; //一级指针是变量地址
	//int **p2 = &(&a) 不允许直接跳级定义
	int** p2 = &p; //二级指针是一级指针地址
	int*** p3 = &p2; //三级指针是二级指针地址
	p3 == &p2;
	*p3 == p2 == &p; //*(&p2) == p2
	**p3 == *p2 == p == &a;
	***p3 == **p2 == *p == a;
	return 0;
}

字符串

指针与字符串

• 字符串的几种定义方式以及区别

char str1[] = {'h', 'i', '\0'};
char str2[] = "hi";
char * str3 = "hi";
//不允许：char * str = {'h', 'i', '\0'};

//区别一：char *定义的相同值字符串地址相同
char * str = "hi"; //地址和str3的地址一样

//区别二：char *定义的字符串时常量，不允许修改
str1[0] = "H"; //可以
str3[0] = "H"; //是一个常量，不可以修改

//字符串 或 字符数组 和普通数组相比的特性：不需要额外提供一个长度的参数，因为每个字符串都有一个'\0'作为结束标记

//注意：直接写 "字符串" 相当于char*的形式，即也是个常量
printf("abc"); //abc也是个常量

常用字符串函数

strcmp

• 作用

比较两个字符串大小，即比较两个字符串的每个字符，从第一个字符开始，如果一样则继续比下一个，最终都一样则返回0，如果不一样，则比较此时字符的ascii值，前者大则返回1，否则返回-1

• 实现

#include<stdio.h>

int myStrcmp(const char* str1, const char* str2)
{
	while (*str1 == *str2)
	{
		if ('\0' == *str1) return 0;
		str1++;
		str2++;
	}
	return *str1 > * str2 ? 1 : -1;
}

int main(void)
{
	char* str1 = "hello109213jkl";
	char* str2 = "hello12";
	int ret = myStrcmp(str1, str2);
	if (ret == 0) printf("str1 == str2");
	else if (ret > 0) printf("str1 > str2");
	else printf("str1 < str2");
	return 0;
}

strncmp

• 语法

int myStrcmp(const char* str1, const char* str2, size_t n);

• 作用

同strcmp，但是可以指定只比较前n个字符

strcpy

• 作用

将源字符串的内容拷贝到目标字符串中

• 实现

#include<stdio.h>

void myStrcpy(const char* src, char* dst)
{
	while (*src) //或者 *src != 0 或者 *src != '\0'
	{
		*dst = *src;
		src++;
		dst++;
	}
	*dst = '\0';
}

int main(void)
{
	char* src = "hell0 world.";
	char dst[15];
	myStrcpy(src, dst);
	printf("dst = %s", dst);
	return 0;
}

• 缺点

dest的存储空间存在小于src空间的情况，因此此方法是非安全的，对此，可以使用安全的 strncpy 方法

strncpy

• 作用

同strcpy

• 语法

char* strncpy(char* dest, const char* src, size_t n);
//n: 无符号整数，表示拷贝的字节数，通常设置为dest的长度。
//注意1：不会自动添加\0结束符
//注意2：n如果超过src的长度，也只会拷贝src长度的字符

strstr

• 语法

char* strstr(char* str, char* substr); //<string.h>

• 作用

获取substr在str中首次出现的位置到str末尾 的 这部分字符串，若不存在，则返回null

• 使用

#include<stdio.h>
#include<string.h>

int main(void)
{
	char* res = strstr("helloabc", "ll");
	printf("res = %s\n", res); //lloabc
	return 0;
}

• 计算子串出现的次数

#include<stdio.h>
#include<string.h>

int substrCount(const char* str, const char* substr)
{
	int res = 0;
	char* p = strstr(str, substr);
	while (NULL != p) {
		res++;
		p += strlen(substr);
		p = strstr(p, substr);
	}
	return res;
}

int main(void)
{
	int res = substrCount("helloworld", "l");
	printf("res = %d\n", res); //3
	return 0;
}

strchr

• 语法

char* strchr(char* str, int c);

• 作用

同strstr，只不过找的是一个字符

• 示例

#include<stdio.h>
#include<string.h>

int main(void)
{
	char* res = strchr("hello", 'l');
	puts(res); //llo
	return 0;
}

strrchr

• 语法

同strchr

• 作用

同strstr，只不过从右边开始找

• 示例

#include<stdio.h>
#include<string.h>

int main(void)
{
	char* res = strrchr("hello", 'l');
	puts(res); //lo
	return 0;
}

strcat

• 语法

char* strcat(char* dest, const char* src);

• 作用

将src拼接到dest后面，并返回拼接后的结果

• 问题

(char* dest[10])存在空间不足的情况，所以需要用户使用时自行确保空间充足

strncat

• 语法

char* strncat(char* dest, const char* src, size_t n);

• 作用

同strcat，但可以指定只拼接的src的前n个长度的字符

• 问题

同strcat

sprintf

• 语法

int sprintf(char* str, const char* format, ...);

• 作用

相当于java的String.format，最终结果存入到第一个参数str中

• 示例

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<string.h>

int main(void)
{
	//char* str = "a"; //是个常量
	char str[6] = {0}; //必须保证空间足够，否则报错
	sprintf(str, "%d%c%d=%d", 1, '+', 1, 1 + 1);
	puts(str);
	return 0;
}

sscanf

• 语法

int sscanf(const char* str, const char* format, ...);

• 作用

相较于scanf，将原来从屏幕输入的格式化字符串，变为从第一个参数str中获取

• 示例

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<string.h>

int main(void)
{
	char str[] = "1+1=2";
	int a, b, c;
	int res = sscanf(str, "%d+%d=%d", &a, &b, &c);
	printf("a = %d\n", a); //1
	printf("b = %d\n", b); //1
	printf("c = %d\n", c); //2
	return 0;
}

strtok

• 语法

char* strtok(char* str, const char* delim);
/*
 str：待分割的字符串，第一次切分时需要传入，后续切分只要传入NULL即可，因为函数在切分后，会将delim之后的字符串保存（静态局部变量），后续如果判断str为NULL时，就会将保存的字符串作为此次用来切分的str
 demim：分隔符，可以传多个，如需要分割.和:，只需".:"即可
 */

• 作用

字符串分割，函数会找到str中首次出现的delim中的任意一个字符，并将原串，即str中该字符替换为\0，然后返回str的首地址，这样接得到str首地址到\0 的这部分 字符串了

• 示例

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<string.h>

int main(void)
{
	//strtoc("abc.com", "."); 不可以，因为这样直接传入的"abc.com"是个常量
	char str[] = "abc.com.cn";
	char* res = strtok(str, ".");
	printf("res = %s\n", res); //abc
	return 0;
}

• 进阶

“abc de f.com%100.cn p”，获取abc de f com 100 cn p

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<string.h>

int main(void)
{
	char* res[50] = {NULL}; //需要初始化，否则是野指针，值为默认的随机数字，而该数字对应的地址上可能是禁止访问的，所以在读取时会报错
	char** p = &res;

	char str[] = "abc de f.com%100.cn p";
	char* ret = strtok(str, ". %"); //第一次切分需要传入str
	*p = ret;
	p++;

	while (NULL != ret)
	{
		ret = strtok(NULL, ". %");
		*p = ret;
		p++;
	}
	
	for (size_t i = 0; i < 10; i++)
	{
		if (NULL != res[i])
		{
			printf("res[%d] = %s\n", i, res[i]); 
		}
	}
	/*
	res[0] = abc
	res[1] = de
	res[2] = f
	res[3] = com
	res[4] = 100
	res[5] = cn
	res[6] = p
	*/
	return 0;
}

atoi & atof & atol

• 语法与作用

int atoi(const char* nptr); //将字符串转为int
float atof(const char* nptr); //将字符串转为float
long atol(const char* nptr); //将字符串转为long

• 示例

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int main(void)
{
	char* str1 = "123";
	int num1 = atoi(str1);
	printf("num1 = %d\n", num1);

	char* str2 = "0.123f";
	float num2 = atof(str2);
	printf("num2 = %.2lf\n", num2); //注意要加上头文件stdlib.h，否则0.00

	char* str3 = "123L";
	long num3 = atol(str3);
	printf("num3 = %ld\n", num3);

	return 0;
}

内存管理

作用域

c语言将变量的作用域分为三种

1. 代码块作用域（即{}范围内的）
2. 函数作用域
3. 文件作用域

局部变量

• 说明

也叫auto自动变量（auto可写可不写），一般情况下，代码块{}内部定义的变量都是自动变量

• 特点

1. 在一个函数内定义，只在该函数范围内有效
2. 在复合语句中定义，只在该复合语句中有效
3. 随着函数调用的结束或复合语句的结束，局部变量的生命周期也随之结束
4. 如果没有被赋予初值，系统会赋予一个随机值

• 生命周期

从定义变量开始，到所属函数对应的栈帧被释放为止

全局变量

• 特点

1. 定义在函数外，可以被本(.c)文件，以及其他文件中的函数共同使用（注意，如果是其他文件中的函数调用，需要使用extern关键字声明）
2. 全局变量的生命周期同程序的运行周期
3. 不同文件的全局变量也不可以重名
4. 如果没有被赋予初值，int类型的赋予0值，其他类型类似

• 生命周期

从程序执行开始（在main函数之前），到程序执行结束为止，即整个程序执行期间

static局部变量

• 说明

作用域依旧是局部代码块，但是只会定义一次，且定义的位置是在全局位置，通常用来做计数器

• 示例

#include<stdio.h>

void test()
{
	static int n = 0;
	printf("n = %d\n", ++n); //1 2 3 4 5
}

int main(void)
{
	for (size_t i = 0; i < 5; i++)
	{
		test();
	}
	return 0;
}

• 生命周期

从程序执行开始（在main函数之前），到程序执行结束为止，即整个程序执行期间

static全局变量

static int a = 10;
也是定义在函数外，但是经过static关键字修饰后，本文件中的全局变量a，只限制于在本文件中使用，即在其他文件中无法通过extern关键字进行声明与使用。

• 生命周期

从程序执行开始（在main函数之前），到程序执行结束为止，即整个程序执行期间

extern全局变量声明

extern int a;
只是声明一个变量，该变量（a）已经在别的文件中定义过了，这里只是声明的作用

全局函数与静态函数

• 说明

在C语言中函数默认都是全局的，使用关键字static可以将函数声明为静态，意味着该函数只能在定义这个函数的文件中使用，在其他文件中不能调用，即使在其他文件中声明这个函数。

• 生命周期

无论是全局函数还是静态函数，也一样都是从程序执行开始（在main函数之前），到程序执行结束为止，即整个程序执行期间

内存4区模型

windows

linux

.text 和 .rodata 链接后会合并，赋予只读权限
.data 和 .bss 链接后会合并，赋予读写权限

常用函数

memset

• 说明

void *memset(void *s,int c,size_t n)
/**
 * 将已开辟内存空间 s 的首 n 个【字节】的值设为值 c
 **/

• 示例

#include<stdio.h>
#include<string.h>

int main(void)
{
	//对应int数组需要注意
	int arr[] = { 1, 2, 3 };
	memset(arr, 1, 3); 
	/*
	表示对arr的前三个字节设为1，而一个int类型对应有4字节，
	所以数字的第一个元素为：00000000 00000001 00000001 00000001
	即：1 + 2^8 + 2^16 = 65793
	*/
	for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("arr[%d] = %d \n", i, arr[i]);
		/*
		arr[0] = 65793
		arr[1] = 2
		arr[2] = 3
		*/
	}

	//一般用于字符数组(字符串)
	char str1[] = { 'a', 'b', 'c', '\0' };
	memset(str1, 'i', 2);
	puts(str1); //iic

	char str2[] = "abc";
	memset(str2, 'u', sizeof(str2) - 1); //避免将最后的'\0'覆盖
	printf("%s", str2); //uuu
	return 0;
}

memcpy

• 说明

void *memcpy(void *str1, const void *str2, size_t n)
/**
 * str1：指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
 * str2：指向要复制的数据源，类型强制转换为 void* 指针。
 * n：要被复制的字节数。
 * 和strcpy的区别在于，无论有多少个'\0'，memcpy都会复制sizeof的n个长度
 **/

• 示例

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main(void)
{
	char str[] = "abc\0def";
	printf("sizeof(str) = %lu \n", sizeof(str)); //8
	char cpy1[10];
	char cpy2[10];
	strncpy(cpy1, str, sizeof(str)); //strcpy遇到\0将停止复制
	memcpy(cpy2, str, sizeof(str)); //memcpy不受\0的影响
	printf("strnpy: %s\n", cpy1 + strlen("abc") + 1); //
	printf("memcpy: %s\n", cpy2 + strlen("abc") + 1); //def
	
	int a[5] = { 1, 2, 3, 4, 5 };
	int b[5];
	memcpy(b, a, sizeof(a));
	return 0;

	//注意不要出现内存重叠
	//如 memcpy(&a[2], a, 5 * sizeof(int))
}

memmove

• 说明

参见memcpy，用于补足内存重叠情形

• 示例

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main(void)
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	memmove(&a[2], a, 5 * sizeof(int));
	for (size_t i = 0; i < sizeof(a)/sizeof(a[0]); i++)
	{
		printf("a[%d] = %d\n", i, a[i]);
		/*
		a[0] = 1
		a[1] = 2
		a[2] = 1
		a[3] = 2
		a[4] = 3
		a[5] = 4
		a[6] = 5
		a[7] = 8
		a[8] = 9
		a[9] = 10
		*/
	}
	return 0;
}

memcmp

• 说明

用于两个值的比较（对于数组从第一个元素逐个向后比较）

• 示例

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main(void)
{
	int a[] = { 1, 2, 3, 4, 5 };
	int b[] = { 1, 3, 2 };
	int res = memcmp(a, b);
	if (res > 0)
	{
		printf("a > b");
	}
	else if (res < 0)
	{
		printf("a < b");
	}
	else {
		printf("a == b");
	}
	//a < b
	return 0;
}

堆空间的使用

malloc & free

• 说明

void* malloc(size_t size); //用于申请堆内存，size为指定的要申请的内存大小（字节数），返回值为申请到的内存地址，一般当做数组来使用
void free(void* ptr); //用于释放申请的堆内存，即释放malloc申请的内存，需要注意的是释放之后这部分内存并不会立即失效，所以往往还会进行赋NULL操作

• 示例

#include<stdio.h>

int main(void)
{
	//int arr[100000] = { 0 }; //超出栈内存容量，直接无法启动，所以此时需要使用堆内存
	int* p = (int*)malloc(10 * sizeof(int)); //申请
    int* tmp = p; //用于free，防止p地址执行了p++等操作，导致地址变化
	for (size_t i = 0; i < 10; i++) //使用：赋值
	{
		p[i] = i + 10;
	}
	for (size_t i = 0; i < 10; i++) //使用：遍历
	{
		printf("p[%d] = %d\n", i, *(p+i));
	}
	free(tmp); //释放，注意不要再释放前对p进行++等操作，因为free要释放的必须是malloc申请的地址
    tmp = NULL; //立即失效
	return 0;
}

二级指针malloc空间

#include<stdio.h>

int main(void)
{
	//1.申请外层空间
	int** p = malloc(sizeof(int*) * 3);
	//2.申请内存空间
	for (size_t i = 0; i < 3; i++)
	{
		p[i] = malloc(sizeof(int) * 5);
	}
	//3.写入数据
	for (size_t i = 0; i < 3; i++)
	{
		for (size_t j = 0; j < 5; j++)
		{
			p[i][j] = i + j;
		}
	}
	//4.读取数据
	for (size_t i = 0; i < 3; i++)
	{
		for (size_t j = 0; j < 5; j++)
		{
			printf("p[%d][%d] = %d\n", i, j, *(*(p + i) + j));
		}
		printf("\n");
	}
	//5.释放内层空间
	for (size_t i = 0; i < 3; i++)
	{
		free(p[i]);
		p[i] = NULL;
	}
	//6.释放外层空间
	free(p);
	p = NULL;
	return 0;
}

复杂数据类型

结构体

结构体说明

struct Student
{
    int age;
    char name[100];
    int score;
};
/*
1. struct是结构体关键字
2. struct Student合起来才是结构体类型（名称）
3. 需要封号结尾
4. 不能在结构体内部直接对定义的变量赋值
    【因为结构体只是一个类型，没有定义变量前是没有分配空间的】
 */

结构体示例

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

struct Student
{
	char name[100];
	int age;
	int score;
};
struct Student2
{
    char name[100];
	int age;
	int score;
} s1 = {"zhangsan", 18, 100}, s2; //可以同时定义（多个）变量，并进行初始化
struct //匿名结构体，只能使用此时定义的变量，不能再创建变量
{
	char name[100];
	int age;
	int score;
} s3, s4;

int main(void)
{
	/* 定义一个结构体类型变量：结构体名称 变量名称 */
	struct Student stu;

	/* 结构体变量初始化：只有在定义的时候才能初始化 */
	struct Student stu1 = { "张三", 18, 100 };

	/* 结构体变量的赋值：.点号(普通变量) / ->箭头(指针变量) */
	struct Student stu11;
	stu11.age = 18; //或：(&stu11) -> age = 19
	//stu11.name = "李四"; 数组是常量，不能直接赋值
	strcpy(stu11.name, "李四"); //或：strcpy((&stu11) -> name, "李四")
	stu11.score = 100; //或：(&stu11) -> score = 100

	struct Student *stu12;
	stu12 = &stu; //注意，如果是野指针，会报错
	stu12->age = 19; //或：(*stu12).age = 19
	strcpy(stu12->name, "王五"); //或：strcpy((*stu12).name, "王五")
	stu12->score = 100; //或：(*stu12).score = 100;

    /* 相同类型的结构体可以进行赋值 */
    struct Student stus999;
    stus999 = stu11; //同 int a = 1; int b; b = a;

	return 0;
}

结构体数组

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

struct Stu
{
	char name[100];
	int age;
};

int main(void)
{
	//定义时初始化
	struct Stu stus1[5] =
	{ //内部的花括号{}可以省略
		{"zhangsan", 1},
		{"lisi", 2},
		{"wangwu", 3},
		{"zhaoliu", 4},
		{"xiaoming", 5}
	};

	//多种赋值方式
	struct Stu stus2[5];
	strcpy(stus2[0].name, "zhangsan");
	stus2[0].age = 12;

	strcpy((stus2 + 1)->name, "lisi");
	(stus2 + 1)->age = 19;

	strcpy((*(stus2 + 2)).name, "wangwu");
	(*(stus2 + 2)).age = 20;

	struct Stu* p = stus2;
	strcpy((p + 3)->name, "zhaoliu");
	(p + 3)->age = 21;

	strcpy(p[4].name, "xiaoming");
	p[4].age = 21;

	for (size_t i = 0; i < sizeof(stus2)/sizeof(stus2[0]); i++)
    {
		printf("name=%s, age=%d \n", stus2[i].name, stus2[i].age);
	}
	return 0;
}

结构体嵌套结构体

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

struct BaseInfo
{
	char name[100];
	int age;
};

struct Player
{
	struct BaseInfo info;
	int score;
};

int main(void)
{
	struct Player player1;
	player1.info.age = 20;
	strcpy(player1.info.name, "zhangsan");
	player1.score = 100;

	struct Player* player2 = &player1;
	strcpy(player2->info.name, "lisi");
	player2->info.age = 21;
	player2->score = 90;

	struct Player player3 = { "wangwu", 22, 91 }; //会自动按顺序赋值

	printf("%s, %d, %d", player2->info.name, player2->info.age, player2->score);
	return 0;
}

结构体指针成员

• 问题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

struct A
{
	char* name;
};

int main(void)
{
	struct A a;
	strcpy(a.name, "abc"); //error：name是个野指针，无法接受拷贝数据
	return 0;
}

• 方案一：指向文字常量区（data区）

int main(void)
{
	struct A a;
	a.name = "abc"; //字符串实质就是其内存首地址，所以相当于：&变量
	return 0;
}

• 方案二：指向栈区内存

int main(void)
{
	struct A a;
	char temp[100];
	a.name = temp;
	strcpy(a.name, "abc");
	puts(temp); //abc
	return 0;
}

• 方案三：指向堆区内存

#include<stdlib.h>
int main(void)
{
	struct A a;
	a.name = (char*)malloc((strlen("abc") + 1) * sizeof(char));
	if (a.name != NULL)
	{
		strcpy(a.name, "abc");
		puts(a.name); //abc
	}
    if (a.name != NULL)
    {
        free(a.name);
        a.name = NULL;
    }
	return 0;
}

• 指针结构体嵌套指针成员

int main(void)
{
	struct A *a;
	//分配内存
	a = (struct A*)malloc(sizeof(struct A));
	a->name = (char*)malloc((strlen("abc") + 1) * sizeof(char));
	//赋值
	strcpy((*a).name, "abc");
	//打印
	printf("name=%s\n", a->name);
	//释放：先内部
	if (a->name != NULL)
	{
		free(a->name);
		a->name = NULL;
	}
	//释放：再外部
	if (a != NULL)
	{
		free(a);
		a = NULL;
	}
	return 0;
}

结构体嵌套二级指针

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

typedef struct Teacher
{
	char* name;
	char** students;
} Teacher;

void allocateSpace(Teacher*** teachers)
{
	if (NULL == teachers) return;
	//1.分配老师数组
	Teacher** tArray = malloc(sizeof(Teacher*) * 3);
	//2.分配老师
	for (size_t i = 0; i < 3; i++)
	{
		tArray[i] = malloc(sizeof(Teacher));
		//3.分配老师姓名并赋值
		tArray[i]->name = malloc(sizeof(char) * 64);
		sprintf(tArray[i]->name, "Teacher_%d", i + 1);
		//4.分配学生数组
		tArray[i]->students = malloc(sizeof(char*) * 5);
		for (size_t j = 0; j < 5; j++)
		{
			//5.分配学生名字并赋值
			(tArray[i]->students)[j] = malloc(sizeof(char) * 64);
			sprintf((tArray[i]->students)[j], "%s_Student_%d", tArray[i]->name, j + 1);
		}
	}
	*teachers = tArray;
}

void showSpace(Teacher** teachers)
{
	if (NULL == teachers) return;
	for (size_t i = 0; i < 3; i++)
	{
		puts(teachers[i]->name);
		for (size_t j = 0; j < 5; j++)
		{
			printf("     %s\n", teachers[i]->students[j]);
		}
	}
}

void freeSpace(Teacher** teachers)
{
	if (NULL == teachers) return;
	for (size_t i = 0; i < 3; i++)
	{
		//1.释放老师名字
		if (NULL != teachers[i]->name)
		{
			free(teachers[i]->name);
			teachers[i]->name = NULL;
		}
		for (size_t j = 0; j < 5; j++)
		{
			//2.释放学生姓名
			if (NULL != teachers[i]->students[j])
			{
				free(teachers[i]->students[j]);
				teachers[i]->students[j] = NULL;
			}
		}
		//3.释放学生数组
		if (NULL != teachers[i]->students)
		{
			free(teachers[i]->students);
			teachers[i]->students = NULL;
		}
		//4.释放老师
		if (NULL != teachers[i])
		{
			free(teachers[i]);
			teachers[i] = NULL;
		}
	}
	//5.释放老师数组
	if (NULL != teachers)
	{
		free(teachers);
		teachers = NULL;
	}
}

int main(void)
{
	Teacher** teachers = NULL;

	//分配内存
	allocateSpace(&teachers);

	//展示数据
	showSpace(teachers);

	//释放内存
	freeSpace(teachers);

	return 0;
}

结构体拷贝

结构体字节对齐

• 字节对齐使得实际占用字节数往往会偏大

#include<stdio.h>

struct Demo1
{
	int a; 
	char b;
};

int main(void)
{
	printf("Demo1: %lu", sizeof(struct Demo1)); //8 【理论上是：4(int) + 1(char) = 5】
	return 0;
}

• 字节对齐的原因

1. 平台原因(移植原因)

不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因(空间换时间)

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问

如上图，在32位操作系统中，数据总线是32位，所以一次读写4字节，如果未对齐，则对于其中的i(int)，需要读取两次才能确定数值，而对齐后只需一次

• 对齐规则

1. 第一个成员偏移量为0
2. 其余成员偏移量为对齐数整数倍
3. 对齐数 = min ("成员中字节数最大者字节数", #pragma pack(指定的对齐数))
4. 如果有嵌套结构体，对齐数取内外层结构体中的较大者
   
   

• 示例一

#include<stdio.h>

struct Demo1
{
	short a;
	char b;
};

int main(void)
{
	/*
	对齐数 = 2
	a: 2 * 0 = 0
	b: 1 * 1 = 1  //自身字节数整数倍，直至对应偏移量位置上可以存储为止
    b: 1 * 2 = 2 //可以

	a a   (0 ~ 1)
	b *   (2 ~ 3)

	*/
	printf("Demo1: %lu", sizeof(struct Demo1)); //4
	return 0;
}

• 示例二

#include<stdio.h>

struct Demo2
{
	short a;
	double b;
	char c[2];
};

int main(void)
{
	/*
	对齐数 = 8(double)
	a: 2 * 0 = 0
	b: 8 * 1 = 8 //该位置上没有存值，可以
	c: 2 * 1 = 1
	c: ...
	c: 2 * 8 = 16

	a a * * * * * *  (0 ~ 7)
	b b b b b b b b  (8 ~ 15)
	c * * * * * * *  (16 ~ 23)

	*/
	printf("Demo2: %lu", sizeof(struct Demo2)); //24
	return 0;
}

• 示例三：嵌套结构体

#include<stdio.h>

int main(void)
{
	typedef struct Demo1
	{
		double a1;
		short b1;
	} Demo1;

	struct
	{
		char a2;
		Demo1 b2;
		int c2;
	} Demo2;
	/*
	对齐数 = 8(double)
	a2: 2 * 0 = 0
	b2: (不可接在外层结构体成员中)
		a1: 8 * 1 = 8
		b1: 2 * 8 = 16
	c2: 4 * 6 = 24 (不可接在结构体b2中)

	a2  *  *  *  *  *  *  *  (0 ~ 7)
	a1 a1 a1 a1 a1 a1 a1 a1  (8 ~ 15)
	b1 b1  *  *  *  *  *  *  (16 ~ 23)
	c2 c2 c2 c2  *  *  *  *  (24 ~ 32)

	*/
	printf("Demo2: %lu", sizeof(Demo2)); //32
	return 0;
}

• 设置对齐数

1. 对齐数 > 最大成员字节数

取最大成员字节数为实质对齐数

#include<stdio.h>
#pragma pack(8)

int main(void)
{
	struct
	{
		char a;
		int b;
	} Demo;
	printf("Demo: %lu", sizeof(Demo)); //8
	return 0;
}

2. 对齐数 < 最大成员字节数

字节数超过对齐数的成员计算偏移量时以对齐数进行计算

#include<stdio.h>
#pragma pack(2) //设置对齐数为2

int main(void)
{
	struct
	{
		char a;
		int b;
	} Demo;
	// 对齐数 = 2
	// a: 1 * 0 = 0
	// b: 2 * 1 = 2
	//
	// a * 
	// b b
	// b b
	printf("Demo: %lu", sizeof(Demo)); //6
	return 0;
}