1.为什么存在动态内存分配
struct S
{
char name[20];
int age;
};
int main()
{
int n = 0;
scanf("%d", &n);
struct S arr[n];//50个 struct S类型的数据
//数组的元素个数为常量
//30 浪费
//60 不够
//
return 0;
}有时候我们需要的空间大小在程序运行的时候才能知道,，而数组元素[]内只能定义为整型常量
，这时候就只能试试动态存开辟了。
(c99中增加了变长数组的概念，但很多的编译器都不支持c99的标准)
2.动态内存函数的介绍
malloc
用途：Allocates memory blocks - 开辟内存块
void *malloc( size_t size );参数：要设置的内存大小，单位字节
返回值：所申请空间的起始地址
int main()
{
//向内存申请10个字节的空间
int* p = (int*)malloc(10 * sizeof(int));//由于返回类型为void* - 需要强制类型转化
return 0;
}注意：当内存不够开辟空间的时候，会返回NULL
int main()
{
//向内存申请10个字节的空间
int* p = (int*)malloc(10 * sizeof(int));//由于返回类型为void* - 需要强制类型转化
if (p == NULL)
{
//打印错误原因的方式
printf("%s\n", strerror(errno));//使用strerror函数 当开辟失败的时候 会把错误信息放在errno里
}
else
{
//正常使用空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
printf("%d ", *(p + i));//使用了一个整型空间后 立马打印
}
}
return 0;
}当内存不够malloc开辟的时候，就会返回空指针
//向内存申请10个字节的空间
int* p = (int*)malloc(INT_MAX);//由于返回类型为void* - 需要强制类型转化
if (p == NULL) //整型最大值
{
//打印错误原因的方式
printf("%s\n", strerror(errno));//使用strerror函数 当开辟失败的时候 会把错误信息放在errno里
}
当动态申请的空间不再使用的时候，就应该还给操作系统 - free()
如果不使用free()函数，在当前程序结束的时候，也会自动把动态申请的空间返还给操作系统，
但如果在程序结束之前，还有其他任务需要执行，此时不再使用的空间还被占用的话就不太合适了
free
free函数用来释放动态开辟的内存
Deallocates or frees a memory block -
void free( void *memblock );free(p);free前：
使用时：
free后：
可以发现free完前后p所指的空间不变，此时程序依然可以通过p指针找到p所指的空间然后修改，
导致p所指的空间被破坏
解决方法：free完再将p设置为NULL - 空指针
free(p);
p = NULL;当不在使用动态内存开辟的空间的时候，使用free函数释放，谁开辟谁释放，否则可能导致内存泄漏
总结：
malloc：
1.如果开辟成功，则返回一个指向开辟好空间的指针。
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
3.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
4.如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
free：
1.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
2.如果参数 ptr 是NULL指针，则函数什么事都不做。
数组是不需要free的
例子：
int main()
{
//代码1
int num = 0;
scanf("%d", &num);
int arr[num] = {0};
//代码2
int* 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
Allocates an array in memory with elements initialized to 0 - 开辟一块空间且初始化为0
void *calloc( size_t num, size_t size );参数：
num：元素的个数
size：每个元素的大小
返回值：
void* ： 所开辟空间的起始地址
int* p =(int*)calloc(10, sizeof(int));//元素的个数 + 每个元素的字节数 同malloc一样，如果内存不够用也会返回NULL(空指针)
int main()
{
void* calloc(size_t num, size_t size);
//malloc(10*sizeof(int));//总大小字节数
int* p =(int*)calloc(10, sizeof(int));//元素的个数 + 每个元素的字节数
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
//开辟成功
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
}
//释放空间
free(p);//free函数用来释放动态开辟的空间
p = NULL;
return 0;
}
calloc - 初始化开辟的空间为0
总结：
1.函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
2.与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
realloc
realloc函数的出现让动态内存管理更加灵活。 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小 的调整。
在实际代码执行过程中，有可能会出现申请的空间不合适的情况，需要增加/删除，这时候realloc就可以调整动态开辟内存的大小。
void *realloc( void *memblock, size_t size );int main()
{
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
else
{
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
}
//只是在使用malloc开辟的20个字节的空间
//假设这里20个字节不能满足我们的使用了
//希望有40个字节的空间
//使用realloc 来调整动态开辟的空间
//
int* p2 = realloc(p, 40);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p2 + i));
}
return 0;
}前五个元素定义为0-4，后五个元素是realloc重新开辟的空间，为随机值
如果待开辟的内存后的空间足够用，就在其后开辟新的空间，然后返回旧的地址返回去。若不够用，则另外开辟一块新的空间，把原来的数据拷贝到新的空间，再返回新的地址，旧的空间free带掉。
p = realloc(p, 40);如果拿原来的地址来接收realloc的返回值，有可能p的地址会改变
例如：
p = realloc(p, 400);
通过监视可以看到，p发生了变化
int* ptr = realloc(p, INT_MAX);
if (ptr != NULL)
{
p = ptr; //开辟成功才赋值给p
}
当realloc开辟空间失败的时候，同时会把p改掉(p原本的值丢失)，所以先用ptr(额外的指针)来接收realloc的返回值，开辟成功再赋值给p
总结：realloc的注意事项
1.如果p指向的空间之后有足够的空间可以追加，则直接追加，然后返回p
2.如果p指向的空间之后没有足够的空间可以追加，则realloc会重新找一块新的内存区域，开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的空间，最后返回新开辟的内存空间的地址。
//使用realloc直接开辟空间
int* p = realloc(NULL,40); // 等价于malloc
使用realloc直接开辟空间
3.常见的动态内存错误
错误1：对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(40);
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
free(p);
p = NULL;
return 0;
}万一malloc开辟空间失败，p就被赋值NULL，对NULL解引用就会出现问题。
错误2：对动态开辟内存的越界访问
int main()
{
int* p = malloc(5 * sizeof(int));
if (p == NULL)
{
return 0;
}
else
{
int i = 0;
for (i = 0; i < 10; i++)//只开辟5个整型大小的字节数 这里越界访问了
{d
*(p + i) = i;
}
}
free(p);
p = NULL;
return 0;
}这里代码会直接挂掉。
错误3：对非动态开辟内存使用free释放
int main()
{
int a = 10;
int* p = &a;
*p = 20;
free(p);
p = NULL;
return 0;
}此时的a是在栈区上开辟的，而不是堆区(动态开辟)的。
此程序一运行就会崩溃。
错误4：使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 0;
}
else
{
int i = 0;
for (i = 0; i < 10; i++)
{
*p++ = i; //++使得p不在指向malloc开辟的空间的起始地址
}
}
free(p);
p = NULL;
return 0;
}++运算符使得p指针后移了，再使用free释放的就不是完整的动态开辟的空间了，p指针指向的不是动态开辟空间的起始位置的时候，就会出问题(只用free释放动态开辟空间的一部分)。
错误5：对同一块动态内存多次释放
int main()
{
//对同一块动态内存的多次释放
int* p = (int*)malloc(40);
if (p == NULL)
{
return 0;
}
else
{
//使用
}
//释放空间
free(p);
//...
free(p);
return 0;
}此代码直接报错。
如何避免二次释放：
free(p);
p = NULL;
//...
free(p);
在free完之后就把p指针赋值为空指针(NULL).
错误6：动态开辟内存忘记释放（内存泄漏）
int main()
{
while (1)
{
malloc(1);//开辟一个字节
}
return 0;
}一直malloc申请空间但不释放，不断的开辟内存，内存大量被占用，
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记： 动态开辟的空间一定要释放，并且正确释放 。
4.几个经典的笔试题
topic1:
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}首先printf(str)写法是没有问题的
int main()
{
//Test();
char* str = "abcdef";
printf(str);
return 0;
}
str存的是常量字符串的首字符地址，等价于printf("abcdef");
再来看这题，
GetMemory(str);注意：GetMemory在传参的时候传的是str本身，并没有传地址，所以形参p是str的一份临时拷贝
所以这里程序相当于是p指向了malloc开辟的空间，而str并没有，然后p相当于是GetMemory函数里的形参变量，在函数内部有效，出了函数就不在了，p不在了就意味着没人记得malloc所指的空间到底在哪，此时str还是NULL(空指针)，strcpy把"hello world"拷贝到str(空指针)里，程序崩溃
str没有指向有效空间
1.运行代码程序会出现崩溃的现象
2.程序存在内存泄漏的问题
str以值传递的形式给p，p是GetMemory的一个形参，只在函数内部有效，GetMemory返回之后，动态开辟的内存尚未释放，并且无法找到，所以会造成内存泄漏。
topic1的修改方法1：
void GetMemory(char** p)//二级指针接收
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//传str的地址
strcpy(str, "hello world");//字符串拷贝
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
修改方法2：
char* GetMemory(char* p)
{
p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory(str);
strcpy(str, "hello world");//字符串拷贝
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}topic2:返回栈空间的地址的问题
char* GetMemory(void)//函数无参
{
char p[] = "hello world";// \0
return p;//首元素地址
}
void Test(void)
{
char* str = NULL;
str = GetMemory();//p所指的空间还给操作系统了
printf(str);
}
int main()
{
Test();
return 0;
}当GetMemory函数结束的时候，p所指的空间就还给操作系统了，这里str就相当于非法访问内存，最后打印的是随机值
解决方法：
char p[] 前面加上static 修饰，延长生命周期
例子2：
int* test()
{
int a = 10;
return &a;//返回栈空间的地址
}
int main()
{
int* p = test();
*p = 20;//访问了非法内存
return 0;
}但如果在堆区上开辟的空间在函数结束的时候就不会被销毁
int* test()
{
int* ptr = malloc(100);//堆区
return ptr;//ptr所指的空间没有被销毁
}
int main()
{
int* p = test();
return 0;
}只有主动free才能回收堆上开辟的空间
没有指向有效空间的指针 - 野指针
topic3：
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}没有释放动态内存，导致内存泄漏，传参传的是str的地址，所以最后会打印hello
topic4：
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);//释放等价于 不在使用这块空间了 再使用就是非法访问空间了
if (str != NULL)//str所指的空间已经释放掉了(返还给操作系统) 但str没有赋值空指针NULL
{
strcpy(str, "world");//world 把hello覆盖了
printf(str);
}
}free释放str指向的空间后，并不会把str置为NULL
5.c/c++程序的开辟
数据段也叫做静态区
全局变量和static修饰的静态变量放在静态区
局部变量放在栈区
动态开辟的空间在堆区的开辟的
当指针指向的是常量字符串的时候，常量字符串存在代码段里(只读常量区)
C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。(os - operating system 操作系统)
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。 但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序 结束才销毁，所以生命周期变长。
6.柔性数组
1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大 小，以适应柔性数组的预期大小。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员
struct S
{
int n;
int arr[];//结构体的最后一个成员 可以是未知大小的
};
int main()
{
struct S s;
return 0;
}
数组大小也可以写成0
struct S
{
int n;
int arr[0];//结构体的最后一个成员 可以是未知大小的
};柔性数组成员 - 数组大小是可以调整的
用sizeof计算s的大小
printf("%d\n", sizeof(s));
可以发现计算的大小，并没有包括数组的大小
struct S* ps =(struct S*)malloc(sizeof(struct S)+5*sizeof(int));
开辟柔性数组大小的方法
第一种写法：
struct S
{
int n;
int arr[0];//结构体的最后一个成员 可以是未知大小的
//柔性数组成员 - 数组大小是可以调整的
};
int main()
{
//struct S s;
//printf("%d\n", sizeof(s));
struct S* ps =(struct S*)malloc(sizeof(struct S)+5*sizeof(int));
ps->n = 100;
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i; // 0 1 2 3 4
}
struct S* ptr = realloc(ps, 44);//
if (ptr != NULL)
{
ps = ptr;//ptr != 空指针 再把ptr赋值给ps
}
for (i = 5; i < 10; i++)
{
ps->arr[i] = i;
}
//打印全部元素
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
free(ps);
ps = NULL;
//释放
return 0;第二种写法：
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
ps->arr = malloc(5*sizeof(int));
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 5; i++)
{
printf("%d ", ps->arr[i]);
}
return 0;
}
此代码使用了两次malloc，需要free两次，就存在free的先后顺序
如果先释放ps所指向的空间，那么arr所指的空间就无法被找到了，所以应该先释放arr所指向的空间。
free(ps->arr);
free(ps);
ps = NULL;
两种写法对比：
与刚刚柔性数组达到了同样的效果
柔性数组的特点(方法一)：
1.法二malloc两次，对应两次free，形式上更容易出错
2.柔性数组开辟的时候n和arr是一次性开辟的，是一块连续的空间，只malloc一次，对应free一次
使用第二种方法，开辟的空间是不连续的，容易出现内存碎片，导致空间利用率越低
且柔性数组n和arr是连续的，访问效率更高
局部性原理：在访问某一块内存的数据的时候 ，接下来80%的可能性访问的是它旁边的数据，
如果数据是连续存放的，那么访问效率就越高
如果寄存器没有想要的数据的话，就去高速缓存拿，高速缓存也没有的话，就去内存拿，一层一层往下访问，效率低
但柔性数组的写法并没有流行起来
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给 用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你 不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好 了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正 你跑不了要用做偏移量的加法来寻址）
1784
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
