宝子，你不点个赞吗？不评个论吗？不收个藏吗？

最后的最后，关注我，关注我，关注我，你会看到更多有趣的博客哦！！！

喵喵喵，你对我真的很重要。

前言

动态内存产生的原因

动态内存函数

malloc

free

calloc

realloc

常见的动态内存错误

对NULL指针的解引用操作

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

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

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

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

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

举几个栗子，Test函数的结果会怎么样？

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

柔性数组

柔性数组的特点：

柔性数组的优势

通讯录（动态内存化）

开辟空间

初始化通讯录

增加联系人（可能需要增容）

销毁通讯录

总结

前言

动态内存不是很难理解，好好看，应该会很不错！B站有很多好视频，那个可能会更容易理解，再练练题建立自信，应该会很棒！宝子加油鸭！爱你呦！喵~

动态内存产生的原因

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：

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

2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

动态内存函数

malloc

void* malloc (size_t size);

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

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

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

free

void free (void* ptr);

free专门是用来做动态内存的释放和回收的

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

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

如果参数 ptr 是NULL指针，则函数什么事都不做。

举个栗子：

malloc和free都声明在 stdlib.h 头文件中。

#include <stdio.h>
int main()
{//代码1int num = 0;scanf("%d", &num);int arr[num] = {0};//代码2int* ptr = NULL;ptr = (int*)malloc(num*sizeof(int));if(NULL != ptr)//判断ptr指针是否为空{int i = 0;for(i=0; i<num; i++){*(ptr+i) = 0；}}free(ptr);//释放ptr所指向的动态内存ptr = NULL;//是否有必要？return 0;
}

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(10, sizeof(int));if(NULL != p){//使用空间}free(p);p = NULL;return 0;
}

realloc

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

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

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

ptr 是要调整的内存地址

size 调整之后新大小

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

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

realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

后面有足够的空间的话，还好。没有足够的空间的话，它会自己另外找足够的空间使用，地址将会改变。

情况1

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

情况2

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。由于上述的两种情况，realloc函数的使用就要注意一些。

举个栗子：

#include <stdio.h>
int main()
{int *ptr = (int*)malloc(100);if(ptr != NULL){//业务处理}else{exit(EXIT_FAILURE);    }//扩展容量//代码1ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)//代码2int*p = NULL;p = realloc(ptr, 1000);if(p != NULL){ptr = p;}//业务处理free(ptr);return 0;
}

常见的动态内存错误

对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释放一块动态开辟内存的一部分
void test()
{int *p = (int *)malloc(100);p++;free(p);//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);
}

举几个栗子，Test函数的结果会怎么样？

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

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

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

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

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

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

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

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

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

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

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

所以生命周期变长。

柔性数组

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

typedef struct st_type
{int i;int a[];//柔性数组成员
}type_a;

柔性数组的特点：

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

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

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

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

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

柔性数组的优势

上述的 type_a 结构也可以设计为：
//代码2
typedef struct st_type
{int i;int *p_a;
}type_a;
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//业务处理
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 的实现有两个好处：

第一个好处是：方便内存释放如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度. 连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

通讯录（动态内存化）

通讯录基础版（点击，看看！）

修改后的源码

//teat.c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"contact.h"
void menu()
{printf("*********************************\n");printf("*****   1.add     2.del    ******\n");printf("*****   3.search  4.modify ******\n");printf("*****   5.show    6.sort   ******\n");printf("*****   7.dea     0.exit   ******\n");printf("*********************************\n");
}
int main()
{int input = 0;//ͨѶ¼PeoInfo  data[1000];int sz = 05l;Contact con;InitContact(&con);do{menu();printf("请输入->");scanf("%d", &input);switch (input){case  1:AddContact(&con);break;case  2:DelContact(&con);break;case  3:SearchContact(&con);break;case  4:ModifyContact(&con);break;case  5:ShowContact(&con);break;case  6:SortContact(&con);break;case  7:/*DeaContact(&con);*/DestoryContact(&con);break;case  0:printf("退出通讯录\n");break;default:printf("选择错误\n");break;}} while (input);return 0;
}


//Contact.c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include"contact.h"
//静态
//void InitContact(Contact* pc)
//{
//  assert(pc);
//  pc->sz = 0;
//  memset(pc->data, 0, sizeof(pc->data));
//}
void InitContact(Contact* pc)
{assert(pc);pc->sz = 0;PeoInfo* ptr = (PeoInfo*)calloc(sizeof(PeoInfo), DEFAULT_SZ);if (ptr == NULL){perror("InitContact::calloc");return;}pc->data = ptr;pc->capacity = DEFAULT_SZ;
}
//void AddContact(Contact* pc)
//{
//  assert(pc);
//  if (pc->sz == 1000)
//  {
//      printf("通讯录已满，无法添加\n");
//      return;
//  }
//  //增加一个人的信息
//  printf("请输入名字:>");
//  scanf("%s", pc->data[pc->sz].name);
//  printf("请输入年龄:>");
//  scanf("%d", &(pc->data[pc->sz].age));
//  printf("请输入性别:>");
//  scanf("%s", pc->data[pc->sz].sex);
//  printf("请输入地址:>");
//  scanf("%s", pc->data[pc->sz].addr);
//  printf("请输入电话:>");
//  scanf("%s", pc->data[pc->sz].tele);
//  pc->sz++;
//}
void check_capacity(Contact* pc)
{if (pc->sz == pc->capacity){//增加容量PeoInfo* ptr = (PeoInfo*)realloc(pc->data, (pc->capacity + 2) * sizeof(PeoInfo));if (ptr == NULL){perror("check_capacity::realloc");return;}pc->data = ptr;pc->capacity += INC_SZ;printf("增容成功");}
}
void AddContact(Contact* pc)
{assert(pc);check_capacity(pc);if (pc->sz == pc->capacity){//增加容量}//增加一个人的信息printf("请输入名字:>");scanf("%s", pc->data[pc->sz].name);printf("请输入年龄:>");scanf("%d", &(pc->data[pc->sz].age));printf("请输入性别:>");scanf("%s", pc->data[pc->sz].sex);printf("请输入地址:>");scanf("%s", pc->data[pc->sz].addr);printf("请输入电话:>");scanf("%s", pc->data[pc->sz].tele);pc->sz++;
}
void ShowContact(const Contact* pc)
{assert(pc);int i = 0;printf("%-20s\t%-4s\t%-5s\t%-20s\t%-15s\n", "名字", "年龄", "性别", "地址", "电话");for (i = 0; i < pc->sz; i++){printf("%-20s\t%-4d\t%-5s\t%-20s\t%-15s\n", pc->data[i].name, pc->data[i].age, pc->data[i].sex, pc->data[i].addr, pc->data[i].tele);}}int FindByName(const Contact* pc, char name[])
{assert(pc);int i = 0;for (i = 0; i < pc->sz; i++){if (strcmp(pc->data[i].name, name) == 0){return i;}}return -1;
}void DelContact(Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };if (pc->sz == 0){printf("通讯录为空，无法删除");return;}//删除//找出要删除的人printf("请输入要删除的人的名字;>");scanf("%s", name);int ret = FindByName(pc, name);if (-1 == ret){printf("要删除的人不存在\n");return;}int i = 0;int del = 0;for (i = 0; i < pc->sz; i++){if (strcmp(pc->data[i].name, name) == 0){del = i;break;}}//删除for (i = del; i < pc->sz; i++){pc->data[i] = pc->data[i + 1];}pc->sz--;printf("删除成功\n");
}void SearchContact(const Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };printf("请输入要查找人的名字:>");scanf("%s", name);int pos = FindByName(pc, name);if (-1 == pos){printf("要查找的人不存在\n");return;}//打印信息printf("%-20s\t%-4s\t%-5s\t%-20s\t%-15s\n", "名字", "年龄", "性别", "地址", "电话");printf("%-20s\t%-4d\t%-5s\t%-20s\t%-15s\n", pc->data[pos].name, pc->data[pos].age, pc->data[pos].sex, pc->data[pos].addr, pc->data[pos].tele);
}void ModifyContact(Contact* pc)
{assert(pc);char name[NAME_MAX] = { 0 };printf("请输入要删除的人的名字;>");scanf("%s", name);int pos = FindByName(pc, name);if (-1 == pos){printf("要删除的人不存在\n");return;}printf("请输入名字:>");scanf("%s", pc->data[pos].name);printf("请输入年龄:>");scanf("%d", &(pc->data[pos].age));printf("请输入性别:>");scanf("%s", pc->data[pos].sex);printf("请输入地址:>");scanf("%s", pc->data[pos].addr);printf("请输入电话:>");scanf("%s", pc->data[pos].tele);printf("修改完成\n");
}//排序函数//1.按照姓名进行排序
int Conpare_ByName(const void* e1, const void* e2)
{return strcmp(((struct PeoInfo*)e1)->name, ((struct PeoInfo*)e2)->name);
}
//2.按照年龄进行排序
int Conpare_ByAge(const void* e1, const void* e2)
{return ((struct PeoInfo*)e1)->age - ((struct PeoInfo*)e2)->age;
}
//3.按照住址进行排序
int Conpare_ByAddress(const void* e1, const void* e2)
{return strcmp(((struct PeoInfo*)e1)->addr, ((struct PeoInfo*)e2)->addr);
}
void SortContact(Contact* pc)
{assert(pc);printf("请选择你想排序的方式：\n");printf("1.姓名\n2.年龄\n3.住址\n");int input = 0;scanf("%d", &input);switch (input){case 1:qsort(pc->data, pc->sz, sizeof(pc->data[0]), Conpare_ByName);printf("排序成功\n");break;case 2:qsort(pc->data, pc->sz, sizeof(pc->data[0]), Conpare_ByAge);printf("排序成功\n");break;case 3:qsort(pc->data, pc->sz, sizeof(pc->data[0]), Conpare_ByAddress);printf("排序成功\n");break;}
}//void DeaContact(Contact* pc)
//{
//  assert(pc);
//  memset(pc->data, 0, sizeof(pc->data));
//  pc->sz == 0;
//  printf("清空成功！\n");
//
//}
void DestoryContact(Contact* pc)
{free(pc->data);pc->data = NULL;pc->sz = 0;pc = NULL;
}

//Contact.h
#pragma once
#define MAX 1000
#define NAME_MAX 20
#define SEX_MAX 5
#define ADDR_MAX 30
#define TELE_MAX 12#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>#define DEFAULT_SZ 3//默认大小
#define INC_SZ 2//人的信息
typedef struct PeoInfo
{char name[NAME_MAX];int age;char sex[SEX_MAX];char addr[ADDR_MAX];char tele[TELE_MAX];
}PeoInfo;struct contact
{struct PeoInfo data[NAME_MAX];int sz;//记录当前已经有的元素个数
};
//静态
//typedef struct Contact
//{
//  PeoInfo data[1000];//存放人的信息
//  int sz;//当前已存放信息的个数
//}Contact;
//动态
typedef struct Contact
{PeoInfo* data;//指向存放人的信息int sz;//当前已存放信息的个数int  capacity;//当前通讯录最大容量
}Contact;
//初始化通讯录
void InitContact(Contact* pc);
//销毁通讯录
void DestoryContact(Contact* pc);
删除所有联系人
//void DeaContact(Contact* pc);
//增加联系人
void AddContact(Contact* pc);
//删除指定联系人
void DelContact(Contact* pc);
//显示通讯录
void ShowContact(const Contact* pc);
//查找指定联系人
void SearchContact(Contact* pc);
//修改指定联系人
void ModifyContact(Contact* pc);
//联系人排序
void SortContact(Contact* pc);
//删除所有联系人

开辟空间

//Contact.h
//静态
//typedef struct Contact
//{
//  PeoInfo data[1000];//存放人的信息
//  int sz;//当前已存放信息的个数
//}Contact;
//动态
typedef struct Contact
{PeoInfo* data;//指向存放人的信息int sz;//当前已存放信息的个数int  capacity;//当前通讯录最大容量
}Contact;

初始化通讯录

//静态
//Contact.c
//void InitContact(Contact* pc)
//{
//  assert(pc);
//  pc->sz = 0;
//  memset(pc->data, 0, sizeof(pc->data));
//}
void InitContact(Contact* pc)
{assert(pc);pc->sz = 0;PeoInfo* ptr = (PeoInfo*)calloc(sizeof(PeoInfo), DEFAULT_SZ);if (ptr == NULL){perror("InitContact::calloc");return;}pc->data = ptr;pc->capacity = DEFAULT_SZ;
}

增加联系人（可能需要增容）

//void AddContact(Contact* pc)
//{
//  assert(pc);
//  if (pc->sz == 1000)
//  {
//      printf("通讯录已满，无法添加\n");
//      return;
//  }
//  //增加一个人的信息
//  printf("请输入名字:>");
//  scanf("%s", pc->data[pc->sz].name);
//  printf("请输入年龄:>");
//  scanf("%d", &(pc->data[pc->sz].age));
//  printf("请输入性别:>");
//  scanf("%s", pc->data[pc->sz].sex);
//  printf("请输入地址:>");
//  scanf("%s", pc->data[pc->sz].addr);
//  printf("请输入电话:>");
//  scanf("%s", pc->data[pc->sz].tele);
//  pc->sz++;
//}
void check_capacity(Contact* pc)
{if (pc->sz == pc->capacity){//增加容量PeoInfo*ptr=(PeoInfo*)realloc(pc->data, (pc->capacity + 2) * sizeof(PeoInfo));if (ptr == NULL){perror("check_capacity::realloc");return;}pc->data = ptr;pc->capacity += INC_SZ;}
}
void AddContact(Contact* pc)
{assert(pc);check_capacity(pc);if (pc->sz == pc->capacity){//增加容量}//增加一个人的信息printf("请输入名字:>");scanf("%s", pc->data[pc->sz].name);printf("请输入年龄:>");scanf("%d", &(pc->data[pc->sz].age));printf("请输入性别:>");scanf("%s", pc->data[pc->sz].sex);printf("请输入地址:>");scanf("%s", pc->data[pc->sz].addr);printf("请输入电话:>");scanf("%s", pc->data[pc->sz].tele);pc->sz++;
}

销毁通讯录

//Contact.h
//销毁通讯录
void DestoryContact(Contact* pc);
删除所有联系人
//void DeaContact(Contact* pc);

//Contact.c
//void DeaContact(Contact* pc)
//{
//  assert(pc);
//  memset(pc->data, 0, sizeof(pc->data));
//  pc->sz == 0;
//  printf("清空成功！\n");
//
//}
void DestoryContact(Contact* pc)
{free(pc->data);pc->data = NULL;pc->sz = 0;pc = NULL;
}

记得还有test.c哦！

总结

最近的知识有些难以理解！越是不懂，那就越要能清楚，越要写成博客！

时间有些紧，最近有很多考试，文章还不够详细，以后复习的时候，文章会进行重做，框架是完整的，只是怕内容不够详细，不便于理解，非常抱歉，以后再次复习的时候进行优化！非常抱歉。

宝子，你不点个赞吗？不评个论吗？不收个藏吗？

最后的最后，关注我，关注我，关注我，你会看到更多有趣的博客哦！！！

喵喵喵，你对我真的很重要。

《小猫猫大课堂》三轮5——动态内存管理（通讯录动态内存化）相关推荐

C语言期末集训2（大一，超基础，小猫猫大课堂的配套练习）——分支结构
更新不易,麻烦多多点赞,欢迎你的提问,感谢你的转发, 最后的最后,关注我,关注我,关注我,你会看到更多有趣的博客哦!!! 喵喵喵,你对我真的很重要. 大一上程序设计期末复习,超基础,小猫猫大课堂配套练 ...
C语言期末集训3（大一，超基础，小猫猫大课堂配套练习）——循环结构
更新不易,麻烦多多点赞,欢迎你的提问,感谢你的转发, 最后的最后,关注我,关注我,关注我,你会看到更多有趣的博客哦!!! 喵喵喵,你对我真的很重要. 大一上程序设计期末复习,超基础,小猫猫大课堂配套练 ...
Java内存管理：Java内存区域 JVM运行时数据区
Java内存管理:Java内存区域 JVM运行时数据区在前面的一些文章了解到javac编译的大体过程.Class文件结构.以及JVM字节码指令. 下面我们详细了解Java内存区域:先说明JVM规范定 ...
C++：内存管理：C++内存管理详解
C++语言内存管理是指:对系统的分配.创建.使用这一系列操作.在内存管理中,由于是操作系统内存,使用不当会造成很麻烦的后果.本文将从系统内存的分配.创建出发,并且结合例子来说明内存管理不当会造成的结果 ...
【C 语言必知必会】内存管理、动态分配内存、野指针
C 语言内存管理.动态分配内存.野指针文章目录 C 语言内存管理.动态分配内存.野指针前言: 1.内存分区 1.1 代码区 1.2.1 全局初始化数据区(静态数据区data段) 1.2.2 未初始 ...
JVM自动内存管理机制——Java内存区域（下）
一.虚拟机参数配置在上一篇<Java自动内存管理机制--Java内存区域(上)>中介绍了有关的基础知识,这一篇主要是通过一些示例来了解有关虚拟机参数的配置. 1.Java堆参数设置 a) ...
鸿蒙系统内存管理,嵌入式系统内存管理-鸿蒙HarmonyOS技术社区-鸿蒙官方战略合作伙伴-51CTO.COM...
1.概述操作系统的内存管理功能用于向操作系统提供一致的地址映射功能和内存页面的申请.释放操作.在嵌入式实时系统中,内存管理根据不同的系统,有不同的策略,对于有些系统支持的虚拟内存管理机制,对于另外一 ...
属性与内存管理(属性与内存管理都是相互关联的)
<span style="font-size:18px;"> 属性与内存管理(属性与内存管理都是相互关联的)第一部分一,属性:属性是OC2.0之后出来的新语法,用来取代 ...
Unity 之 Mono内存管理与泄漏 — 内存是手游的硬伤(转)
WeTest导读内存是游戏的硬伤,如果没有做好内存的管理问题,游戏极有可能会出现卡顿,闪退等影响用户体验的现象.本文介绍了在腾讯游戏在Unity游戏开发过程中常见的Mono内存管理问题,并介绍了一系 ...

《小猫猫大课堂》三轮5——动态内存管理（通讯录动态内存化）

前言

动态内存产生的原因

动态内存函数

malloc

free

calloc

realloc

常见的动态内存错误

对NULL指针的解引用操作

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

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

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

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

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

举几个栗子，Test函数的结果会怎么样？

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

柔性数组

柔性数组的特点：

柔性数组的优势

通讯录（动态内存化）

开辟空间

初始化通讯录

增加联系人（可能需要增容）

销毁通讯录

总结

《小猫猫大课堂》三轮5——动态内存管理（通讯录动态内存化）相关推荐

最新文章

热门文章