第五章 动态内存管理

1.存在动态内存分配的意义

2.动态内存函数

• malloc

• free

• calloc

• realloc

3.常见的动态内存错误

4.经典笔试题

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

6.柔性数组

1.存在动态内存分配的意义

    int x = 5; //在栈空间中开辟了大小为4个字节的空间char arr[5] = { 0 }; //在栈空间上开辟了5个连续的字节空间。

以上开辟空间的方式有两个特点：

1.空间开辟的大小是固定的。

2.数组在声明的时候，必须要指定数组的长度，编译时分配所需要的内存空间。
有时候需要的空间大小在程序运行后才知道，以上的开辟空间方式就不能满足了。

2.动态内存函数

2.1 malloc和free

动态内存开辟函数：

void* malloc (size_t size);

该函数会向内存申请一块连续可用的空间，并返回指向该空间的指针。

开辟成功，则返回一个指向开辟好的空间的指针。

开辟失败，则返回一个NULL指针。

返回值类型为void*，malloc函数不知道要开辟什么类型的空间，在使用的时候要自己决定。

size为0时，malloc的行为是标准是未定义的，取决编译器。

动态内存的释放和回收函数：

void free (void* ptr)

用来释放动态开辟的内存。

参数ptr所指向的空间不是动态开辟的，那么free函数的行为是未定义的。

参数ptr是NULL指针的话，则函数什么都不做。

#include <stdio.h>
#include <stdlib.h>int main()
{//1int num = 0;scanf("%d", &num);int arr[num] = { 0 };//2int* ptr = NULL;ptr = (int*)malloc(num * sizeof(int));if (ptr != NULL){int i = 0;for (i = 0; i < num; i++){*(ptr + i) = 0;}}free(ptr);ptr = NULL;return 0;
}

2.2 calloc

calloc也可以用来进行动态内存分配。

void* calloc (size_t num, size_t size);

num个大小为size的元素开辟一块空间，并把空间每个字节都初始化为0。

与malloc不同的是calloc会在返回地址之前把申请的空间都初始化为0。

#include <stdio.h>
#include <stdlib.h>int main()
{int* p = (int*)calloc(5, sizeof(int));if (p != NULL){//使用空间}free(p);p = NULL;return 0;
}

如果对申请的空间需要初始化，可以使用calloc函数来完成。

2.3 realloc

realloc函数让动态内存管理更加灵活。

有时申请的空间太小了又或者太大了，为了合理的分配内存，需要对内存的大小做灵活的调整。realloc函数就可以对动态开辟内存大小进行调整。

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

• ptr为需要调整的内存地址。

• size为调整之后的新大小。

• 返回值为调整后的内存起始位。

• 该函数调整原函数内存空间大小的基础上，还会把原来内存中数据移动到新的空间。

• realloc在调整空间时存在两种情况：

1.原有空间之后有足够大的空间，要扩展内存就直接在原在内存之后追加空间，原先空间的数据不会发生变化。

2.原有空间之后没有足够大的空间时，扩展内存就会在堆空间上另外找一个大小合适的连续空间使用。函数返回的是新的内存地址。

#include <stdio.h>
#include <stdlib.h>int main()
{//1int* ptr = (int*)malloc(100);if (ptr != NULL){}else{perror(main);}ptr = realloc(ptr, 1000);//2int* p = NULL;p = (int* )realloc(ptr,1000);if (p != NULL){ptr = p;}else{perror(main);}free(ptr);ptr = NULL;return 0;
}

3.常见的动态内存错误

3.1 对NULL指针的解引用操作

int main()
{int* p = (int*)malloc(INT_MAX/ 2);*p = 10; //如果p的值为NULL,会出现问题。free(p);p = NULL;return 0;
}

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

int main()
{int i = 0;int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){return;}for (i = 0; i <= 10; i++){*(p + i) = i; //到i=10时，会出现越界访问的问题。}free(p);p = NULL;return 0;
}

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

int main()
{int a = 10;int* p = &a;free(p);  //这种做法是错误的，return 0;
}

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

int main()
{int* p = (int*)malloc(10);p++;free(p); //此时p不再指向初始地址.return 0 ;
}

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

int main()
{int* p = (int*)malloc(10);free(p);free(p); //重复释放return 0;
}

3.6 动态开辟内存忘记释放(内存泄漏)

void test()
{int* p = (int*)malloc(100);if (p != NULL){*p = 10;}
}int main()
{test();return 0;
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

动态开辟的空间一定要释放，且正确释放。

4.经典题

4.1 题1：

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

结果：崩溃

4.2 题2：

char *GetMemory(void)
{char p[] = "hello world";return p;
}void Test(void)
{char *str = NULL;str = GetMemory();printf(str);
}int main()
{Test();return 0;
}

结果：随机值

4.3 题3：

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

结果：hello

4.4 题4：

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;
}

结果：world

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

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

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

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

所以生命周期变长。

6.柔性数组

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

struct S
{int a;int arr[0];  //柔性数组成员
};

部分编译器会报错可改成：

struct S
{int a;int arr[];  //柔性数组成员
};

6.1 柔性数组的特点

• 结构中柔性数组成员前面必须至少一个其他成员。

• sizeof返回的结构大小不包括柔性数组的内存。

• 包含柔性数组的结构需要使用malloc函数进行内存的动态分配，且分配的内存该大于结构的大小，以适应柔性数组的预期大小。

typedef struct s_ct
{int a;int arr[0];
}ct_a;int main()
{printf("%d\n", sizeof(ct_a));  //通过以上的描述，可以知道这里输出的是4.return 0;
}

6.2 柔性数组的使用

typedef struct s_ct
{int a;int arr[0];
}ct_a;int main()
{ct_a* p = (ct_a*)malloc(sizeof(ct_a) + 10*sizeof(int));p->a = 10;int i = 0;for (i = 0; i < 10; i++){p->arr[i] = i;}free(p);p = NULL;return 0;
}

这里的柔性数组a，相当获得了10个整型元素的连续空间。

6.3 柔性数组的优势

6.2中的代码还可以这样写：

typedef struct s_ct
{int a;int *pa;
}ct_a;int main()
{ct_a* p = (ct_a*)malloc(sizeof(ct_a));p->a = 10;p->pa = (ct_a*)malloc(p->a * sizeof(int));int i = 0;for (i = 0; i < 10; i++){p->pa[i] = i;}free(p->pa);p->pa = NULL;free(p);p = NULL;return 0;
}

6.2和6.3的代码可以实现相同的功能，但6.2的方法更好。

原因：

1.方便内存释放

如果把结构体的内存及成员的内存一次性分配好，并返回一个结构体指针，那么只需要做一次free就可以把内存释放掉。是给别人使用的函数中，在里面做二次分配，他人可以通过free释放，但不知道该结构体内的成员也需要free释放。

2.有利于访问速度

连续的内存有利于提高访问的速度，也有利于减少内存碎片。

练习：

1.模拟实现atoi

#include <stdio.h>
#include <limits.h>
#include <ctype.h>enum State
{INVALID,VALID
};enum State state = INVALID;int my_atoi(const char* p)
{int flag = 1;if (p == NULL){return 0;}if (*p == '\0'){return 0;}while (isspace(*p)){p++;}if (*p == '+'){flag = 1;p++;}else if (*p == '-'){flag = -1;p++;}long long n = 0;while (isdigit(*p)){n = n * 10 + flag * (*p - '0');if (n < INT_MIN || n>INT_MAX){return 0;}p++;}if (*p == '\0'){state = VALID;return (int)n;}else{return (int)n;}
}int main()
{const char* p = "   -14a";int ret = my_atoi(p);if(state == VALID)printf("合法：%d\n", ret);elseprintf("非法：%d\n", ret);return 0;
}

2.一个数组中只有两个数组出现了一次，其他所有数字都出现两次。编写一个函数找出这两个只出现一次的数字。

#include <stdio.h>void Find(int arr[], int sz, int* x1, int* y1)
{int i = 0;int ret = 0;for (i = 0; i < sz; i++){ret ^= arr[i];}int Pos = 0;for (i = 0; i < 32; i++){if (((ret >> i) & 1) == 1){Pos = i;break;}}int num1 = 0;int num2 = 0;for (i = 0; i < sz; i++){if (((arr[i] >> Pos) & 1) == 1){num1 ^= arr[i];}else{num2 ^= arr[i];}}*x1 = num1;*y1 = num2;
}int main()
{int arr[] = { 1,2,3,4,5,6,1,2,3,4 };int x = 0;int y = 0;int sz = sizeof(arr) / sizeof(arr[0]);Find(arr, sz, &x, &y);printf("%d %d",x, y);return 0;
}

上一章：C语言深入学习 — 4.自定义类型(结构体+枚举+联合)

配套练习：

C语言练习题110例(一)
C语言练习题110例(二）
C语言练习题110例(三)
C语言练习题110例(四)
C语言练习题110例(五)
C语言练习题110例(六)
C语言练习题110例(七)
C语言练习题110例(八)
C语言练习题110例(九)
C语言练习题110例(十)
C语言练习题110例(十一)