自定义变量和动态内存

---

一、自定义变量

1、枚举

1.1 枚举是什么？

顾名思义就是一一列举，把可能的取值一一列举。
比如一周的七天

示例如下

enum Color//enum 关键字 
{
	//枚举的值是常量，不能被修改
	//可以给它定个初值 
	BLUE,
	GREEN,
	RED
};

1.2 枚举的优点

1、增加代码的可读性和可维护性
2、和#define定义的标识符比较枚举有类型检查，更加严谨。
3、防止了命名污染（封装）
4、便于调试
5、使用方便，一次可以定义多个常量

2、联合体

2.1 联合体是什么？

联合体是一种特殊的自定义类型，定义的变量包含了一系列的成员，特征是这些成员公用同一块空间（所以也称为共用体）。
示例如下：

union un
{
	char ch;
	int i;
	double b;
};

2.2联合体应用以及特点

联合体大小是成员中最大的那个空间。
示例如下：

int check_sys()
{
	union un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}

int main()
{
	int ret = check_sys();
	if (1 == ret)
	{
		printf("小端\n");
	}
	else
	{
		printf("小端\n");
	}
	return 0;
}

2.3 联合体大小计算

联合的大小至少是最大成员的大小
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
示例如下：

union un 
{
	char ch[5];//5 1 8 取1
	int i;//4 8 取4 整体应该取4的整数倍，所以选择8
};

int main()
{
	printf("%zd\n", sizeof(union un));//8
	return 0;
}

二、动态内存管理

1.malloc和free

声明都是放在<stdlib.h>头文件中

1.1 malloc

动态开辟内存函数malloc:void* malloc（size_t size);
malloc 开辟的空间里面默认放置随机值，函数参数是整个空间字节大小
这个函数向内存申请一块连续可用的空间,并返回指向这片空间的指针。

• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个NULL指针，因此对malloc的返回值一定要做检查。
• 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体使用的时候使用者自己来决定（使用强制类型转换实现）。
• 如果参数size 为0 ，malloc的行为是标准是未定义，取决于编译器。

1.2 free

专门用来做动态内存的释放和回收。函数原型void free（void* ptr）

• 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的。
• 如果参数ptr是NULL指针，则函数什么事都不不做。

malloc和free ，calloc和free。需要成对出现。即使成对出现因为逻辑问题也很有可能出现内存泄露

2 calloc和realloc

2.1 calloc

函数原型void* calloc（int num ,size_t size）
calloc 开辟的空间里面默认放置0，函数参数是单个空间的数量，单个空间的大小。
可以认为 calloc=malloc+memset；

2.2 realloc

函数原型void* realloc（void* ptr ，size_t size）；
realloc函数的出现让动态内存管理更加灵活。
realloc函数可以做到对动态开辟内存大小的调整。

• ptr是要调整的内存地址
• size是调整后新大小
• 返回值为在调整之后的内存起始地址位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移到新的空间。
• realloc在调整内存空间的是存在两种情况：

3.常见动态内存错误

3.1 对空指针的解引用操作

//对NULL指针的解引用操作

int main()
{
	int *p = (int*)malloc(INT_MAX);//必须对malloc的返回值进行合理的判断
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	else
	{
	* *p = 5;
	}

	free(p);
	p = NULL;

	return 0;
}

3.2 对动态开辟空间的越界访问

int main()
{
	int*p = (int*)malloc(20);
	if (p == NULL)
		return 1;
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;//这里形成对开辟空间的越界访问
		//p[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", p[i]);
	}
	//释放
	free(p);
	p = NULL;
	return 0;
//}

3.3 对非动态开辟内存使用free释放

int main()
{
	int num = 10;
	int*p = #

	//.....

	free(p);
	p = NULL;

	return 0;
}

会造成程序运行崩溃

3.4 使用free释放动态开辟内存的一部分

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 5; i++)
	{		
		*p = i;
		p++;
	}
	//释放
	//在释放的时候，p指向的不再是动态内存空间的起始位置
	free(p);
	p = NULL;

	return 0;
}

释放起始位置不一样，释放的时候也会造成程序崩溃

3.5 对同一动态开辟的内存多次释放

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 1;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	
	free(p);
	p = NULL;//这里将原来的指针置为空指针，就不会造成后面再次释放的程序崩溃

	free(p);
	return 0;
}

3.6 动态开辟的内存忘记释放（内存泄露）

void get_memory()
{
	int* p = (int*)malloc(40);
	//....
	free(p);
	p = NULL;
}

//函数会返回动态开辟空间的地址，记得在使用之后返回
int* get_memory()
{
	int* p = (int*)malloc(40);
	//....
	return p;
}


int main()
{
	int *ptr = get_memory();
	//使用

	//释放
	free(ptr);//如果这里不采取释放，就会造成内存泄露
	ptr = NULL;
	
	return 0;
}