【day26】练习和柔性数组

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

练习
一些常考的动态内存问题
参数传递问题

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	//这里是值传递，不是地址，所以上面的GetMemory函数的参数是一份临时拷贝，p在申请后，函数结束形参p被销毁，又发生了内存泄露，此时str还是空指针。
	strcpy(str, "hello world");
	printf(str);
}

返回地址空间问题
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
	//虽然地址被传过去了，但是这里char p的生命周期在GetMemory函数结束时就结束了
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

没有free

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

free后没有置空指针

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main() {
	Test();
	return 0;
}

C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结
   束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的
   内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁所以生命周期变长

int globalVar              = 1;  //数据段
static int staticGlobalVar = 1;  //数据段

void Test() {
	static int staticVar   = 1;  //数据段
	int localVar           = 1;  //栈
	int num1[10] = { 1,2,3,4 };  //栈
	char char2[] = "abcd";       // = 号前在栈上，后面的"abcd"在代码段上
	char* pChar3 = "abcd";       // = 号前在栈上，后面的"abcd"在代码段上
	int* ptr1 = (int*)malloc(4 * sizeof(int));       // = 号前在栈上，后面的内存函数在堆上
	int* ptr2 = (int*)calloc(4 ,sizeof(int));        // = 号前在栈上，后面的内存函数在堆上
	int* ptr3 = (int*)realloc(ptr2,4 * sizeof(int)); // = 号前在栈上，后面的内存函数在堆上
	 
	free(ptr1);                 //栈
	free(ptr3);                 //栈
}
|———————————————————————————|
|          内核空间          |
|      (用户代码不能读写)    |
|———————————————————————————|
|                           |
|———————————————————————————|
|        栈(向下增长)↓       |
|———————————————————————————|
|                           |
|———————————————————————————|
|          内存映射段        |
|(文件映射、动态库、匿名映射) |
|———————————————————————————|
|                           |
|———————————————————————————|
|         堆(向上增长)↑      |
|———————————————————————————|
|                           |
|———————————————————————————|
|           数据段           |
|     (全局数据、静态数据)    |
|———————————————————————————|
|           代码段           |
|     (可执行代码/只读常量)   |
|———————————————————————————|

#define INT_PTR int*
typedef int* int_ptr;
INT_PTR a,b;// #define 修饰的是替换，所以代码等价与 int* a,b;等价于：int *a;和int b;
int_ptr a,b;//typedef 是重新定义类型，所以等价于：int* a;int* b;

柔性数组

C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

柔性数组的特点

1. 结构中的柔性数组成员前面必须至少一个其他成员。
2. sizeof 返回的这种结构大小不包括柔性数组的内存。
3. 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

代码1

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员  
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4

柔性数组的使用

int main() {
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int)); //这样柔性数组成员a，相当于获得了100个整型元素的连续空间。
	//业务处理
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);

	return 0;
}

柔性数组的优势
代码2

```c
typedef struct st_type
{
	int i;
	int* p_a;//使用指针
}type_a;
int main() {

	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//业务处理
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
}

代码1 和 代码2 可以完成同样的功能，但是 代码1 的实现有两个好处
第一个好处是：方便内存释放
方法2需要二次内存分配，并把整个结构体返回。当我们调用free释放结构体时，需要把结构体的内存以及其成员要的内存分别释放。
所以，把结构体的内存以及其成员要的内存一次性分配好了，并返回一个结构体指针，那么做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速
连续的内存有益于提高访问速度，也有益于减少内存碎片。