C语言：动态内存管理

1.为什么存在动态内存分配

想申请变长数组、想申请大块内存
之前的变量我们只是把它定义出，然后计算机（系统）帮我们在栈上申请空间，释放空间，这些我们都不需要管。但有时我们需要的空间大小在程序运行时才知道，而且在栈上开辟不出太大的空间，动态内存管理就是帮我们解决这些事，在堆上申请内存…

• 举个栗子

int a = 10;//在栈上开辟四个字节的大小
char arr[10] = { 0 };//在栈上开辟10个字节的连续空间

上面开辟空间的大小是固定的
数据在定义时，必须指定数组的长度，它所需要的内存在编译时分配(定长数组)

2.动态内存函数的介绍

在堆上内存申请，由程序员申请、释放

malloc和free

内存申请

void* malloc(size_t size);//size：应该申请多少字节的空间

• 开辟成功，将第一个字节的地址返回
• 开辟失败，返回NULL指针，因此malloc的返回值一定要判空
• 返回值是void*,所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定

释放

void free(void* ptr);

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

free并没有告诉我们要释放几个字节，malloc在申请时会多申请字节来保存申请信息
如果不free，会导致内存泄漏（程序退出，内存泄漏就被清理了）

calloc

void* calloc(size_t num,size_t size);

• 函数的功能是给num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0.
• 与malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0

int main()
{
 int n = 10;
 //char *ptr = (char*)malloc(n*sizeof(char));
 char *ptr = (char*)calloc(n,sizeof(char));
 if (NULL == ptr)//
 {
  perror("malloc");
  return;
 }
 //申请成功
 int i = 0;
 for (; i < n; i++)
 {
  ptr[i] = i;
 }
 free(ptr);
 ptr = NULL;
 return 0;
}

realloc

realloc可以对动态开辟内存大小的调整

void* realloc(void* ptr,size_t size);
//eg:int *ptr=(int*)realloc(p1,sizeof(int)*4);
//将p1调整为sizeof(int)*4大小

• 第一个参数是 要调整的内存地址，第二个参数是调整之后的新大小，返回值是调整之后的内存起始位置
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

realloc在调整内存空间时有两种情况：
1.原有空间之后有足够大的空间
2.原有空间之后没有足够大的空间

int main()
{
 int n = 0;
 printf("Please Enter:\n");
 scanf("%d", &n);
 char *ptr = (char*)malloc(n*sizeof(char));
 if (NULL == ptr)
 {
  perror("malloc");
  return 1;
 }
 //申请成功
 int i = 0;
 for (; i < n; i++)
 {
  ptr[i] = i;
 }
 printf("before:%p\n", ptr);
 char*q = realloc(ptr, n);
 if (q == NULL)
 {
  printf("realloc error!\n");
  free(ptr);//
  ptr = NULL;
  return 2;
 }
 else
 {
  ptr = q;//用一个指针，这样可以使自己看更清楚，使用更方便，
 }
 printf("after:%p\n", q);
 free(ptr);
 ptr = NULL;
 return 0;
}

3.常见的动态内存错误

对NULL指针的解引用操作

void test() {
 int *p = (int *)malloc(INT_MAX / 4);
 *p = 20;//如果p的值是NULL，就会有问题    
 free(p);
}

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

void test()
{
 int i = 0;
 int *p = (int *)malloc(10 * sizeof(int));
 if (NULL == p)
 {
  exit(EXIT_FAILURE);
 }
 for (i = 0; i <= 10; i++)
 {
  *(p + i) = i;//当i是10的时候越界访问
 }
 free(p);
}

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?free释放的是堆上的空间
}

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

void test()
{
 int *p = (int *)malloc(100);
 p++;//p不再指向动态内存的起始位置
 //堆空间必须整体申请整体释放
 free(p);
}

对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

动态开辟内存忘记释放（内存泄漏）

void test()
{
 int *p = (int *)malloc(100);
 if (NULL != p)
 {
  *p = 20;
 }
}
int main()
{
 test();
 while (1);
}

经典笔试题

题目1
题目2：
请问运行Test 函数会有什么样的结果？

//返回局部变量或临时变量的地址
char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
int main()
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
 system("pause");
 return 0;
}

题目3：
请问运行Test 函数会有什么样的结果？

//程序正常运行，传的是地址（与题目1比较下）
void GetMemory(char **p, int num)
{
 *p = (char *)malloc(num);
}
int main()
{
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
 system("pause");
 return 0;
}

题目4：
请问运行Test函数会有什么样的结果？

/malloc申请的空间没有判空
//free释放了空间就是非法的了，最后会输出word
int main()
{
 char *str = (char *)malloc(100);
 strcpy(str, "hello");
 free(str);
 if (str != NULL)
 {
  strcpy(str, "world");
  printf(str);
 }
 system("pause");
 return 0;
}