【C 语言】内存管理 ( 动态内存分配 | 栈 | 堆 | 静态存储区 | 内存布局 | 野指针 )

相关文章链接 : 1.【嵌入式开发】C语言 指针数组 多维数组 2.【嵌入式开发】C语言 命令行参数 函数指针 gdb调试 3.【嵌入式开发】C语言 结构体相关 的 函数 指针 数组 4.【嵌入式开发】gcc 学习笔记(一) - 编译C程序 及 编译过程 5.【C语言】 C 语言 关键字分析 ( 属性关键字 | 常量关键字 | 结构体关键字 | 联合体关键字 | 枚举关键字 | 命名关键字 | 杂项关键字) 6.【C 语言】编译过程 分析 ( 预处理 | 编译 | 汇编 | 链接 | 宏定义 | 条件编译 | 编译器指示字 ) 7.【C 语言】指针 与 数组 ( 指针 | 数组 | 指针运算 | 数组访问方式 | 字符串 | 指针数组 | 数组指针 | 多维数组 | 多维指针 | 数组参数 | 函数指针 | 复杂指针解读)

一. 动态内存分配 1. 动态内存分配相关概念 ( 1 ) 动态内存分配 ( ① 变量 数组 -> 内存别名 | ② 变量 在 编译阶段 分配内存 | ③ 除了编译器分配的内存 还需额外内存 -> 动态内存 )

动态内存分配 :

• 1.C语言操作与内存关系密切 : C 语言中的所有操作都与内存相关 ;
• 2.内存别名 : 变量 ( 指针变量 | 普通变量 ) 和 数组 都是在 内存中的别名 ;
  • ( 1 ) 分配内存的时机 : 在编译阶段, 分配内存 ;
  • ( 2 ) 谁来分配内存 : 由 编译器来进行分配 ;
  • ( 3 ) 示例 : 如 定义数组时必须指定数组长度, 数组长度在编译的阶段就必须指定 ;
• 3.动态内存分配的由来 : 在程序运行时, 除了编译器给分配的一些内存之外, 可能 还需要一些额外内存才能实现程序的逻辑, 因此在程序中可以动态的分配内存 ;

2. 动态内存分配 相关方法 ( 1 ) 相关 方法简介 ( ① malloc calloc realloc 申请内存 | ② free 归还内存 | ③ malloc 申请内存 , 不初始化值 | ④ calloc 申请内存 并 初始化 0 | ⑤ realloc 重置已经申请的内存 )

动态内存分配方法 :

• 1.申请内存 : 使用 malloc 或 calloc 或 realloc 申请内存;

• 2.归还内存 : 使用 free 归还 申请的内存 ;

• 3.内存来源 : 系统专门预留一块内存, 用来响应程序的动态内存分配请求 ;

• 4.内存分配相关函数 :

  • ( 1 ) malloc : 单纯的申请指定字节大小的动态内存, 内存中的值不管 ;
  • ( 2 ) calloc : 申请 指定元素大小 和 元素个数的 内存, 并将每个元素初始化为 0 ;
  • ( 3 ) realloc : 可以重置已经申请的内存大小 ;

       #include 

       void *malloc(size_t size);
       void free(void *ptr);
       void *calloc(size_t nmemb, size_t size);
       void *realloc(void *ptr, size_t size);

( 2 ) malloc 函数 ( ① void malloc(size_t size) ; size 字节大小 | ② 返回值 void 需要强转为指定类型 | ③ 系统实际分配内存比 malloc 稍大 | ④ 如果内存用完会返回 NULL )

malloc 函数简介 :

void *malloc(size_t size);

• 1.作用 : 分配一块连续的内存 , 单位 字节, 该内存没有具体的类型信息 ;
• 2.函数解析 :
  • ( 1 ) size_t size 参数 : 传入一个字节大小参数 , size 是要分配的内存的大小 ;
  • ( 2 ) void * 返回值 : 返回一个 void* 指针, 需要强制转换为指定类型的指针 , 该指针指向内存的首地址 ;
• 3.请求内存大小 : malloc 实际请求的内存大小可能会比 size 大一些, 大多少与编译器和平台先关 , 这点知道即可, 不要应用到编程中 ;
• 4.申请失败 : 系统为程序预留出一块内存用于 在程序运行时 动态申请, 当这块预留的内存用完以后, 在使用 malloc 申请, 就会返回 NULL ;

( 3 ) free 函数 ( ① void free(void *ptr) | ② 作用 : 释放 malloc 申请的动态空间 | ③ 参数 : void *ptr 指针指向要释放的内存首地址 | ④ 返回值 : 没有返回值 )

free 函数简介 :

void free(void *ptr);

• 1.作用 : 释放 malloc 函数申请的 动态空间 ;
• 2.函数解析 : 该函数 没有返回值 ;
  • *( 1 ) void ptr 参数 : 要释放的内存的首地址;
• 3.传入 NULL 参数 : 假如 free 方法传入 NULL 参数, 则直接返回, 不会报错 ;

( 4 ) calloc 函数 ( ① void *calloc(size_t nmemb, size_t size) | ② 作用 : 申请 指定元素个数 指定元素大小 的内存 , 并将每个元素初始化成 0 | ③ size_t nmemb 参数 : 元素个数 | ④ size_t size 参数 : 元素大小 )

calloc 函数简介 :

void *calloc(size_t nmemb, size_t size);

• 1.作用 : 比 malloc 先进一些, 可以申请 ① 指定元素个数 ② 指定元素大小 的内存 ;
• 2.函数解析 :
  • ( 1 ) void * 类型返回值 : 返回值是一个 void * 类型, 需要转换为实际的类型才可以使用 ;
  • ( 2 ) size_t nmemb 参数 : 申请内存的元素 个数 ;
  • ( 3 ) size_t size 参数 : 申请内存的元素 大小 ;
• 3.内存中的值初始化 : calloc 分配动态内存后, 会将其中每个元素的值都初始化为 0 ;

( 5 ) realloc 函数 ( ① void *realloc(void *ptr, size_t size) | ② 作用 : 重新分配一个已经分配并且未释放的动态内存的大小 | ③ void *ptr 参数 : 指向 一块已经存在的动态内存空间的首地址 | ④ size_t size 参数 : 需要重新分配内存大小 | ⑤ ptr 参数为 NULL , 函数与 malloc 作用一样 | ⑥ 要使用新地址 旧地址 ptr 不能继续使用了 )

realloc 函数简介 :

void *realloc(void *ptr, size_t size);

• 1.作用 : 重新分配一个已经分配并且未释放的动态内存的大小 ;
• 2.函数解析 :
  • ( 1 ) void * 类型返回值 : 重新分配后的指针首地址, 与参数 ptr 指向的地址是相同的, 但是需要使用 返回的新地址 , 不能再使用老地址了 ;
  • *( 2 ) void ptr 参数 : 指向 一块已经存在的动态内存空间的首地址 ;
  • ( 3 ) size_t size 参数 : 需要分配的新内存大小 ;
• 3.void *ptr 参数为 NULL : 如果传入的 ptr 参数为 NULL, 那么该函数执行效果与 malloc 一样, 直接分配一块新的动态内存, 并返回一个指向其首地址的指针 ;

( 6 ) 代码示例 ( 动态内存分配简单示例)

代码示例 :

• 1.代码 :

#include 
#include 

int main()
{
	//1. 使用 malloc 分配 20 个字节的内存, 这些内存中的数据保持原样
	int* p1 = (int*)malloc(sizeof(int) * 5);
	
	//2. 使用 calloc 分配 5 个 int 类型元素的 内存, 初始化 5 个元素的值为 0
	int* p2 = (int*)calloc(5, sizeof(int));
	
	//3. 以 int 类型 打印 p1 和 p2 指向的内存中的数据值
	int i = 0; 
	for(i = 0; i  old ebp -> 数据
		( 6 ) 执行函数体 : 开始执行 main 函数的函数体, 执行 fun1 函数, 下面是 栈 中内存变化 : 
		
	2. 调用 fun1 函数, 继续将 fun1 函数内容入栈 : 
		( 1 ) 参数入栈 : 将 fun1 参数 入栈 
		( 2 ) 返回地址入栈 : 存放一个返回地址, 此时存放的是栈顶的值 address2 地址, 返回的时候通过 ebp 指针回退一个读取 ;
		( 3 ) ebp 指针入栈 : old ebp (上次 ebp 指针指向的地址) 指针指向的地址值入栈, 该指针指向 address1 地址, 即 ebp 指针上一次指向的位置, 
				该栈内存中存放 ebp 指针上次指向的地址 address1, 这段存放 address1 的内存首地址为 address3,
				ebp 指针指向 address3 , 即 ebp 指针变量存储 address3 的地址值, 栈内存中的 address3 存放 address1 地址 ; 
		( 3 ) 数据入栈 : 存放数据 (局部变量) 
		( 4 ) esp 指向栈顶 : esp 指向 栈顶 
		( 5 ) 执行函数体 : 开始执行 fun1 函数体内容, 执行结束后需要出栈 返回 ;
		
	3. fun1 函数执行完毕, 开始 退栈 返回 操作 : 
		( 1 ) 获取返回地址 : 返回地址存放在 ebp 的上一个指针地址, ebp 指向 返回地址的尾地址, 
				ebp 回退一个指针位置即可获取返回地址 , 此时的返回地址是 address2 上面已经描述过了 ;
		( 2 ) esp 指针指向 : esp 指向 address2, 即将 esp 指针变量的值 设置为 address2 即可 ;
		( 3 ) ebp 指针指向 : 
					获取上一个 ebp 指向的地址 : 当前 ebp 指向的内存中存储了上一个 ebp 指向的内存地址, 获取这个地址;
					ebp 指向这个刚获取的地址 ; 
		( 4 ) 释放栈空间 : 将 esp 指针指向的当前地址 和 之后的地址 都释放掉 ; 
		
		( 5 ) 执行 main 函数体 : 继续执行 main 函数 函数体 , 然后执行 fun2 函数; 
		
		
	4. 执行 fun2 函数
		( 1 ) 参数入栈 : fun2 函数参数入栈; 
		( 2 ) 返回地址 入栈 : esp 指向的地址 存放到 返回地址中 ; 
		( 3 ) ebp 地址入栈 : 将 ebp 指向的地址存放到栈内存中, ebp 指向 该段内存的首地址 (即返回地址的尾地址);
		( 4 ) 数据入栈 : 将数据 入栈
		( 5 ) esp 指向栈顶 : esp 指向 数据 的末尾地址 ; 
		
		( 6 ) 执行函数体 : 执行 fun2 函数体时, 发现 fun2 中居然调用了 fun1, 此时又要开始将 fun1 函数入栈 ; 
		
		
	5. fun1 函数入栈
		( 1 ) 参数入栈 : 将 fun1 参数入栈
		( 2 ) 返回地址入栈 : esp 指向的 返回地址 存入栈内存 ; 
		( 3 ) ebp 地址入栈 : 将 old ebp 地址 入栈, 并且 ebp 指针指向 该段 栈内存首地址 (即 返回地址 的尾地址);
		( 4 ) 数据入栈 : 局部变量, 寄存器值 入栈 ;  
		( 5 ) esp 指针指向 : esp 指针指向栈顶 ; 
		
		( 6 ) 执行函数体 : 继续执行函数体, 执行完 fun1 函数之后, 函数执行完毕, 开始出栈操作 ; 
		
	6. fun1 函数 出栈
		( 1 ) esp 指针返回 : 通过 ebp 读取上一个指针, 获取 返回地址, esp 指向 返回地址, 即上一个栈顶 ; 
		( 2 ) ebp 指针返回 : 读取 ebp 指针指向的内存中的数据, 这个数据是上一个 ebp 指针指向的地址值, ebp 指向这个地址值; 
		( 3 ) 释放栈空间 : 执行完这两个操作后, 栈空间就释放了 ; 
		
		( 4 ) 执行函数体 : 执行完 fun1 出栈后, 继续执行 fun2 中的函数体, 发现 fun2 函数体也执行完了, 开始 fun2 出栈 ; 
		
	7. fun2 函数 出栈 
		( 1 ) esp 指针返回 : 通过 ebp 读取上一个指针, 获取 返回地址, esp 指向 返回地址, 即上一个栈顶 ; 
		( 2 ) ebp 指针返回 : 读取 ebp 指针指向的内存中的数据, 这个数据是上一个 ebp 指针指向的地址值, ebp 指向这个地址值; 
		( 3 ) 释放栈空间 : 执行完这两个操作后, 栈空间就释放了 ; 
		
		( 4 ) 执行函数体 : 执行完 fun2 出栈后, 继续执行 main 中的函数体, 如果 main 函数执行完毕, esp 和 ebp 都指向 栈底 ; 
	
*/
int main()
{
	fun1(1);
	fun2(1);
	
	return 0;
}

• 2.编译运行结果 : 没有输出结果, 编译通过 ;

( 3 ) 栈内存行为分析 ( 图文分析版本 )

分析的代码内容 :

#include 

void fun1(int i)
{
}

int fun2(int i)
{
	fun1();
	return i;
}

int main()
{
	fun1(1);
	fun2(1);
	
	return 0;
}

代码 栈内存 行为操作 图示分析 :

• 1.main 函数执行 :
  • ( 1 ) 参数入栈 : 将 参数 放入栈中, 此时 main 函数 参数 在栈底 ;
  • ( 2 ) 返回地址入栈 : 然后将 返回地址 放入栈中, 返回地址是 栈底地址 ;
  • ( 3 ) ebp 指针入栈 : 将 old ebp 指针入栈, ebp 指针指向 old ebp 存放的地址 address1 , 这个 address1 是 栈底地址;
  • ( 4 ) 数据入栈 : ( 局部变量, 寄存器的值 等 ) ;
  • ( 5 ) esp 指向栈顶 : esp 指针指向 栈顶 (即数据后面的内存首地址), 此时栈顶数据 address2;
  • ( 6 ) 数据总结 : main 的栈中 栈底 到 栈顶 的数据 : main 参数 -> 返回地址 -> old ebp -> 数据
  • ( 7 ) 执行函数体 : 开始执行 main 函数的函数体, 执行 fun1 函数, 下面是 栈 中内存变化 :

int main()
{
	fun1(1);
	fun2(1);
	
	return 0;
}

• 2.调用 fun1 函数, 继续将 fun1 函数内容入栈 :
  • ( 1 ) 参数入栈 : 将 fun1 参数 入栈 ;
  • ( 2 ) 返回地址入栈 : 存放一个返回地址, 此时存放的是栈顶的值 address2 地址, 返回的时候通过 ebp 指针回退一个读取 ;
  • ( 3 ) ebp 指针入栈 : old ebp (上次 ebp 指针指向的地址) 指针指向的地址值入栈, 该指针指向 address1 地址, 即 ebp 指针上一次指向的位置, 该栈内存中存放 ebp 指针上次指向的地址 address1, 这段存放 address1 的内存首地址为 address3, ebp 指针指向 address3 , 即 ebp 指针变量存储 address3 的地址值, 栈内存中的 address3 存放 address1 地址 ;
  • ( 4 ) 数据入栈 : 存放数据 (局部变量) ;
  • ( 5 ) esp 指向栈顶 : esp 指向 栈顶 ;
  • ( 6 ) 执行函数体 : 开始执行 fun1 函数体内容, 执行结束后需要出栈 返回 ;

void fun1(int i)
{
}

• 3.fun1 函数执行完毕, 开始 退栈 返回 操作 :
  • ( 1 ) 获取返回地址 : 返回地址存放在 ebp 的上一个指针地址, ebp 指向 返回地址的尾地址, ebp 回退一个指针位置即可获取返回地址 , 此时的返回地址是 address2 上面已经描述过了 ;
  • ( 2 ) esp 指针指向 : esp 指向 address2, 即将 esp 指针变量的值 设置为 address2 即可 ;
  • ( 3 ) ebp 指针指向 : 获取上一个 ebp 指向的地址 : 当前 ebp 指向的内存中存储了上一个 ebp 指向的内存地址, 获取这个地址; ebp 指向这个刚获取的地址 ;
  • ( 4 ) 释放栈空间 : 将 esp 指针指向的当前地址 和 之后的地址 都释放掉 ;
  • ( 5 ) 执行 main 函数体 : 继续执行 main 函数 函数体 , 然后执行 fun2 函数;

int main()
{
	fun1(1);
	fun2(1);
	
	return 0;
}

• 4.执行 fun2 函数 :
  • ( 1 ) 参数入栈 : fun2 函数参数入栈;
  • ( 2 ) 返回地址 入栈 : esp 指向的地址 存放到 返回地址中 ;
  • ( 3 ) ebp 地址入栈 : 将 ebp 指向的地址存放到栈内存中, ebp 指向 该段内存的首地址 (即返回地址的尾地址);
  • ( 4 ) 数据入栈 : 将数据 入栈 ;
  • ( 5 ) esp 指向栈顶 : esp 指向 数据 的末尾地址 ;
  • ( 6 ) 执行函数体 : 执行 fun2 函数体时, 发现 fun2 中居然调用了 fun1, 此时又要开始将 fun1 函数入栈 ;

int fun2(int i)
{
	fun1();
	return i;
}

• 5.fun1 函数入栈 :
  • ( 1 ) 参数入栈 : 将 fun1 参数入栈 ;
  • ( 2 ) 返回地址入栈 : esp 指向的 返回地址 存入栈内存 ;
  • ( 3 ) ebp 地址入栈 : 将 old ebp 地址 入栈, 并且 ebp 指针指向 该段 栈内存首地址 (即 返回地址 的尾地址);
  • ( 4 ) 数据入栈 : 局部变量, 寄存器值 入栈 ;
  • ( 5 ) esp 指针指向 : esp 指针指向栈顶 ;
  • ( 6 ) 执行函数体 : 继续执行函数体, 执行完 fun1 函数之后, 函数执行完毕, 开始出栈操作 ;

void fun1(int i)
{
}

• 6.fun1 函数 出栈 :
  • ( 1 ) esp 指针返回 : 通过 ebp 读取上一个指针, 获取 返回地址, esp 指向 返回地址, 即上一个栈顶 ;
  • ( 2 ) ebp 指针返回 : 读取 ebp 指针指向的内存中的数据, 这个数据是上一个 ebp 指针指向的地址值, ebp 指向这个地址值;
  • ( 3 ) 释放栈空间 : 执行完这两个操作后, 栈空间就释放了 ;
  • ( 4 ) 执行函数体 : 执行完 fun1 出栈后, 继续执行 fun2 中的函数体, 发现 fun2 函数体也执行完了, 开始 fun2 出栈 ;

int fun2(int i)
{
	fun1();
	return i;
}

• 7.fun2 函数 出栈 :
  • ( 1 ) esp 指针返回 : 通过 ebp 读取上一个指针, 获取 返回地址, esp 指向 返回地址, 即上一个栈顶 ;
  • ( 2 ) ebp 指针返回 : 读取 ebp 指针指向的内存中的数据, 这个数据是上一个 ebp 指针指向的地址值, ebp 指向这个地址值;
  • ( 3 ) 释放栈空间 : 执行完这两个操作后, 栈空间就释放了 ;
  • ( 4 ) 执行函数体 : 执行完 fun2 出栈后, 继续执行 main 中的函数体, 如果 main 函数执行完毕, esp 和 ebp 都指向 栈底 ;

2. 堆 ( 1 ) 标题3

堆 相关 概念 :

• 1.栈的特性 : 函数执行开始时入栈, 在函数执行完毕后, 函数栈要释放掉, 因此函数栈内的部分类型数据无法传递到函数外部 ;
• 2.堆 空间 : malloc 动态申请内存空间, 申请的空间是操作系统预留的一块内存, 这块内存就是堆 , 程序可以自由使用这块内存 ;
• 3.堆 有效期 : 堆空间 从申请获得开始生效, 在程序主动释放前都是有效的, 程序释放后, 堆空间不可用 ;

堆 管理 方法 :

• 1.空闲链表法 ;
• 2.位图法 ;
• 3.对象池法 ;

空闲链表法方案 :

• 1.空闲链表图示 : 表头 -> 列表项 -> NULL ;

• 2.程序申请堆内存 : int* p = (int*)malloc(sizeof(int)) ; 申请一个 4 字节的堆空间, 从空闲链表中查找能满足要求的空间, 发现一个 5 字节的空间, 满足要求, 这里直接将 5 字节的空间, 分配给了程序 , 不一定要分配正好的内存给程序, 可能分配的内存比申请的要大一些 ;

• 3.程序释放堆内存 : 将 p 指向的内存插入到空闲链表中 ;

3. 静态存储区 ( 1 ) 标题3

静态存储区 相关概念 :

• 1.静态存储区 内容 : 静态存储区用于存储程序的静态局部变量 和 全局变量 ;
• 2.静态存储区大小 : 在程序编译阶段就可以确定静态存储区大小了, 将静态局部变量和全部变量 的大小相加即可 ;
• 3.静态存储区 生命周期 : 程序开始运行时分配静态存储区, 程序运行结束后释放静态存储区 ;
• 4.静态局部变量 : 静态局部变量在程序运行过程中, 会一直保存着 ;

总结 : 1.栈内存 : 主要存储函数调用相关信息 ; 2.堆内存 : 用于程序申请动态内存, 归还动态内存使用 ; 3.静态存储区 : 用于保存程序中的 全局变量 和 静态局部变量 ;

三. 程序内存布局 1. 程序运行前的程序文件的布局 ( 代码段 | 数据段 | bss段 ) (1) 相关概念简介

可执行程序文件的内容 : 三个段 是程序文件的信息, 编译后确定 ;

• 1.文本段 ( .text section ) : 存放代码内容, 编译时就确定了, 只能读, 不能写 ;
• 2.数据段 ( .data section ) : 存放 已经初始化的 静态局部变量 和 全局变量, 编译阶段确定, 可读写 ;
• 3.BSS段 ( .bss section ) : 存放 没有初始化的 静态局部变量 和 全局变量, 可读写 , 程序开始执行的时候 初始化为 0 ;

( 2 ) 分析程序文件的内存布局

分析简单程序的 程序文件布局 :

• 1.示例代码 :

#include 

//1. 全局的 int 类型变量, 并且进行了初始化, 存放在 数据段
int global_int = 666;
//2. 全局 char 类型变量, 没有进行初始化, 存放在 bss段
char global_char;

//3. fun1 和 fun2 函数存放在文本段
void fun1(int i)
{
}

int fun2(int i)
{
	fun1();
	return i;
}

int main()
{
	//4. 静态局部变量, 并且已经初始化过, 存放在 数据段;
	static int static_part_int = 888;
	//5. 静态局部变量, 没有进行初始化, 存放在 bss段;
	static char static_part_char;
	
	//6. 局部变量存放到文本段
	int part_int = 999;
	char part_char;

	//7. 函数语句等内容存放在文本段
	fun1(1);
	fun2(1);
	
	return 0;
}

• 2.代码分析图示 :

2. 程序运行后的内存布局 ( 栈 | 堆 | 映射文件数据 [ bss段 | data段 | text段 ] ) ( 1 ) 相关概念简介

程序运行后的内存布局 : 从高地址 到 低地址 介绍, 顺序为 栈 -> 堆 -> bss段 -> data 段 -> text段 ;

• 1.栈 : 程序运行后才分配栈内存, 存放程序的函数信息 ;
• 2.堆 : 分配完栈内存后分配堆内存, 用于响应程序的动态内存申请 ;
• 3.bss 段 : 从程序文件映射到内存空间中 , 存放 没有初始化的 静态局部变量 和 全局变量, 其值自动初始化为 0 ;
• 4.data 段 : 从程序文件映射到内存空间中 , 存放 已经初始化过的 静态局部变量 和 全局变量 ;
• 5.text 段 : 从程序文件映射到内存空间中 , 存放编写的程序代码 ;
• 6.rodata 段 : 存放程序中的常量信息 , 只能读取, 不能修改, 如 字符串常量, 整形常量 等信息 , 如果强行修改该段的值, 在执行时会报段错误 ;

3. 总结

程序内存总结 :

• 1.静态存储区 : .bss 段 和 .data 段 是静态存储区 ;
• 2.只读存储区 : .rodata 段存放常量, 是只读存储区 ;
• 3.栈内存 : 局部变量存放在栈内存中 ;
• 4.堆内存 : 使用 malloc 动态申请 堆内存 ;
• 5.代码段 : 代码存放在 .text 段 中 , 函数的地址 是代码段中的地址 ;

函数调用过程 :

• 1.函数地址 : 函数地址对应着程序内存空间中代码段的位置 ;
• 2.函数栈 : 函数调用时, 会在栈内存中建立 函数调用的 活动记录, 如 参数 返回地址 old ebp地址 数据 等 ;
• 3.相关资源访问 : 函数调用时, 在代码段的函数存放内存操作信息, 执行函数时, 会根据 esp 栈顶指针 查找函数的 局部变量等信息, 需要静态变量会从 bss 段 或 data段 查找信息, 需要常量值时 去 rodata 段去查找信息 ;

四. 野指针 ( 程序BUG根源 ) 1. 野指针相关概念 ( 1 ) 野指针简介

野指针相关概念 :

• 1.野指针定义 : 野指针的 指针变量 存储的地址值值 不合法 ;
• 2.指针合法指向 : 指针只能指向 栈 和 堆 中的地址, 除了这两种情况, 指针指向的其它地址都是不合法的 ;
• 3.空指针 与 野指针 : 空指针不容易出错, 因为可以判断出来, 其指针地址为 0 ; 野指针指针地址 不为 0 , 但是其指向的内存不可用 ;
• 4.野指针不可判定 : 目前 C 语言中 无法判断 指针 是否 为野指针 ;

( 2 ) 野指针的三大来源

野指针来源 :

• 1.局部变量指针未初始化 : 局部指针变量, 定以后, 没有进行初始化 ;

#include 
#include 

//1. 定义一个结构体, 其中包含 字符串 和 int 类型元素
struct Student
{
	char* name;
	int age;
};

int main()
{
	//2. 声明一个 Student 结构体变量但是没有进行初始化, 
	//	结构体中的两个元素都是随机值
	//  需要 malloc 初始化该局部变量
	struct Student stu;
	
	//3. 向 stu.name 指针指向的地址 写入 "Bill Gates" 字符串, 
	//		要出事, stu.name 没有进行初始化, 其地址是随机值, 
	//		向一个随机地址中写入数据, 会出现任意情况, 严重会直接让系统故障
	//4. 此时 stu.name 就是一个野指针
	strcpy(stu.name, "Bill Gates");
	
	stu.age = 63;
	return 0;
}

• 2.使用已经释放的指针 : 指针指向的内存控件, 已经被 free 释放了, 之后在使用就变成了野指针 ; 如果该指针没有分配, 写入无所谓; 如果该地址被分配给程序了, 随意修改该值会造成无法估计的后果;

#include 
#include 
#include 

int main()
{
	//1. 创建一个字符串, 并为其分配空间
	char* str = (char *)malloc(3);
	//2. 给字符串赋值, 申请了 3 个字节, 但是放入了 11 个字符
	//   有内存越界的风险
	strcpy(str, "HanShuliang");
	//3. 打印字符串
	printf("%s\n", str);
	//4. 释放字符串空间
	free(str);
	//5. 再次打印, 为空
	printf("%s\n", str);
}

• 3.指针指向的变量在使用前被销毁 : 指针指向的变量如果被销毁, 这个变量所在的空间也可能被分配了, 修改该空间内的内容, 后果无法估计;

#include 

//从函数中返回的局部变量要注意一定要是值传递, 不能有地址传递
//局部变量在函数执行完就释放掉了

char * fun()
{
	//注意该变量是局部变量, 
	//函数执行完毕后该变量所在的栈空间就会被销毁
	char* str = "Hanshuliang";
	return str;
}

int main()
{
	//从 fun() 函数中返回的 str 的值是栈空间的值, 
	//该值在函数返回后就释放掉了, 
	//当前这个值是被已经销毁了
	char * str = fun();
	
	//打印出来的值可能是正确的
	printf("%s\n", str);
}

2. 经典指针错误分析 (本节所有代码都是错误示例) ( 1 ) 非法内存操作

非法内存操作 : 主要是**结构体的指针成员出现的问题, 如结 ① 构体指针未进行初始化(分配动态内存, 或者分配一个变量地址), 或者***② 进行了初始化, 但是超出范围使用***;

• 1.结构体成员指针未初始化 : 结构体的成员中 如果有指针, 那么这个指针在使用时需要进行初始化, 结构体变量声明后, 其成员变量值是随机值, 如果指针值是随机值得话, 那么对该指针操作会产生未知后果; 错误示例 :

#include 

//在结构体中定义指针成员, 当结构体为局部变量时, 该指针成员 int* ages 需要手动初始化操作
struct Students
{
	int* ages;
};

int main()
{
	//1. 在函数中声明一个结构体局部变量, 结构体成员不会自动初始化, 此时其中是随机值 
	struct Students stu1;
	
	//2. 遍历结构体的指针成员, 并为其赋值, 但是该指针未进行初始化, 对一个随机空间进行操作会造成未知错误
	int i = 0;
	for(i = 0; i