malloc

void *malloc( size_t size );

Tips:这里的size代表的是字节的大小

malloc的使用:
//malloc的使用 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include
<string.h> #include <errno.h> #include <stdlib.h> int main() { int* str = 0;
int* p = 0; str = (int*)malloc(10*sizeof(int));//开辟十个整型空间 if (NULL == str) {
printf("%s\n", strerror(errno));//若开辟失败 //使用报错函数strerror(errno)
要引用头文件<string.h> } else { p = str; } free(p); p = NULL; return 0; }
free

释放申请的内存空间,例:free(p)

当释放后,虽然p中的值还在,不变,但p就为野指针了。所以建议释放后将p设置为空指针。(p=NULL)

calloc

calloc:开辟并且初始化为0的数组。

void* calloc(size_t num,size_t size)

* num——元素个数
* size——元素大小
成功的话返回地址,失败返回空指针NULL

calloc的使用:
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <string.h>
#include <errno.h> #include <stdlib.h> int main() { int* str = 0; int* p = 0;
str = (int*)calloc(10,sizeof(int)); if (NULL == str) { printf("%s\n",
strerror(errno)); } else { p = str; } free(p); p = NULL; return 0; }
realloc

可开辟空间,也可以调整空间。

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

* memblock——要开辟空间的指针类型
* size——要开辟的字节大小
p=(int)realloc(p,80)*——这样子写也是有风险的。

风险:
为了避免可能会把增容的后面的已有的内存空间给覆盖掉,所以会在另一块大小足够的地方开辟空间,然后把原来的数据转移到新的空间上。并且把原来的内存空间给释放掉。

若realloc调整空间失败,则返回NULL。原来的数据也没有了。

realloc的使用改进:
int* ptr=(int*)realloc(p,80); if(NULL!=ptr) {
p=ptr;//这样子能够保证确定了不为空指针后才正式传给p,相当于没有了会失去原来数据的风险 }
realloc的另一种用法:

int* p=(int*)realloc(NULL,40);这种写法相当于malloc

常见的动态内存错误

对空指针的解引用操作

将malloc函数开辟一个贼大的空间,INT_MAX,此时会有一个空指针,进行判断,如果为空指针就立马结束这个程序了。不要出问题(ps:这里的INT_MAX的使用要引用头文件limits.h)

所以要判断是不是空指针,是的话就中断,例:
//错误写法 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include
<limits.h> #include <string.h> #include <errno.h> #include <stdlib.h> int
main() { int i = 0; int* p = (int*)malloc(INT_MAX); for (i = 0; i < 5; i++) {
*(p + i) = i; } return 0; } //正确写法: #define _CRT_SECURE_NO_WARNINGS 1 #include
<stdio.h> #include <limits.h> #include <string.h> #include <errno.h> #include
<stdlib.h> int main() { int i = 0; int* p = (int*)malloc(INT_MAX); if (p ==
NULL) { printf("%s\n", strerror(errno));//这里是将错误报出来 return 0;//发现是空指针,提前结束 }
for (i = 0; i < 5; i++) { *(p + i) = i; } return 0; }
对动态开辟空间的越界访问

不可以不申请即使用动态内存空间,会报错的。

Tips:没有开辟的空间是不能使用的

对非动态开辟内存使用free释放
int main() { int p=0; int* a=&p; free(a);//这个样子是错误的 return 0; }
使用free释放一块动态开辟内存的一部分

开辟动态空间的时候,一定要把起始位置给用变量存好,否则到时会无法释放内存。
//使用free释放一块动态开辟内存的一部分 //正确写法: #define _CRT_SECURE_NO_WARNINGS 1 #include
<stdio.h> #include <stdlib.h> int main() { int i = 0; int* p = (int*)malloc(10
* sizeof(int)); //正确写法: for (i = 0; i < 5; i++) { *(p + i) = i; } free(p);
p=NULL; return 0; } //错误写法: #define _CRT_SECURE_NO_WARNINGS 1 #include
<stdio.h> #include <stdlib.h> int main() { int i = 0; int* p = (int*)malloc(10
* sizeof(int)); //错误写法: for (i = 0; i < 5; i++) { *p = i;
p++;//这里会改变p的原始位置,使得无法指向一开始开辟动态内存空间的位置,最终报错 } free(p); p = NULL; return 0; }
对同一块动态内存多次释放

一块空间释放后不可再释放,但释放完后p置为空指针再次释放时不会报错。

Q:free空指针时会有问题么?

A:不会,因为一块空间释放后就不能再次释放了,所以每次free完后记得置为空指针。

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

即使在函数中开辟内存空间也要记得释放。因为出了函数在外面想释放也无法释放。

但如果返回首元素的地址,free了也行,就是无论怎么样,一定要释放。

在任何地方开辟的内存空间都最好要释放。

找出下面问题:

T1:
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; }
出现的问题:

 
在这里str是空指针,而p只是新建的一个形参,运行完函数后无法返回p不存在了,但是内存空间还未被释放,而这个空间的地址此时是没有人能够知道的。也并不能将str里面的NULL改变,所以在strcpy时会出错,因为str此时为NULL指针,会造成非法访问内存,程序会崩溃。

而且在使用过程中只进行了动态内存的开辟,没有进行动态内存的释放,可能会造成动态内存泄露。

改进方法:
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h>
#include <string.h> 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; }
函数的栈帧与创建:p尽管销毁,因为会先把p里面的值放入到寄存器中,寄存器里面不会销毁,之后再从寄存器位置传进去str。

 

T2:

出现的问题:

返回栈空间地址问题:

这里虽然能把p的地址传回去,但是在函数运行完后在函数里面创建的数据会被销毁,也就是说虽然能通过指针找到原来的内存所指向的地方,但是数据都以被销毁。

注意!!!

这样是可以的,因为返回的是栈空间的变量而不是栈空间的地址。

总结:

在创造函数如果返回地址而不是返回值,在用的时候可能依然是在函数内的值,但也有很大可能不是,可能不是的原因是有关函数栈帧方面,如果在引用地址前再写上一段例如:"printf("23333\n");",可能会导致覆盖掉原来地址上的数据,所以无法通过传址来输出真正的值,因为会被覆盖掉。

T3:

出现的问题:

除了free没有太大毛病了。这里能够打印出hello。

T4:

 出现的问题:

这里的free其实是把动态内存空间还给系统了,但是str的话没有定为空指针,仍然存着当初指向开辟的内存空间的地址,那么就还可以通过str找到当初开辟的内存空间,只是这个时候因为释放(free)str了,所以此时没有访问空间的权限,也就无法将world拷贝到str所指向的空间。

正确改法:

所以,在每次free后面都要记得设置为空指针。

柔性数组

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

柔性数组的定义
//写法一: struct s1 { int n; int arr[0];//大小是未指定 } //写法二: struct s2 { int n; int
arr[];//大小是未指定 } //总会有一种写法编译器不报错
Tips:在计算包含柔性数组大小的时候,柔性数组是不计算在大小里面的。(可以写一个来试一下)

柔性数组的特点:

* 柔性数组前至少需要一个其他成员
* sizeof返回的这种结构大小不包括柔性数组的内存
* 包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
柔性数组的开辟(自己先写)

包含柔性数组的结构体不可以直接创建,而是要有malloc来开辟空间。
//写柔性数组的方法一: #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include
<stdlib.h> #include <string.h> struct p { int i; int arr[]; }; int main() {
struct p* cmp = (struct p*)malloc(sizeof(struct p) +
80);//这里是开辟了一共84个字节空间,分给arr数组80个字节空间 free(p); p = NULL; return 0; }
//写柔性数组的方法二:(先开辟整个的,再开辟数组的) #define _CRT_SECURE_NO_WARNINGS 1 #include
<stdio.h> #include <stdlib.h> #include <string.h> struct p { int i; int*
arr;//这样才能在方法二中使用 }; int main() { struct p* cmp = (struct
p*)malloc(sizeof(struct p)); cmp->i = 10; cmp->arr =
(int*)malloc(80);//从数组开始,再次开辟80个字节空间 free(p); p = NULL; return 0; }
第二种方案(劣势):

* 开辟和释放的次数多,容易出错
* 频繁多次开辟内存,会有内存碎片出现,可能会导致内存的使用效率不高
第一种方案优势:

* 方便释放
* 减少内存碎片的出现

技术
©2019-2020 Toolsou All rights reserved,
在算法研究过程中如何进行算法创新七大排序算法(java代码)MYSQL中的索引与事务———javaweb(8)(面试必考)2022蓝桥杯JavaB组省赛试题网络安全-wifi攻防网络层协议——ICMP协议MySQL查询表中指定条件下的最新记录JavaSE笔记(一)Java基础语法mysql 查询条件之外的数据_mysql 查询符合条件的数据qt使用数据库sqlite