目录
malloc
void* malloc(size_t size)
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
- 如果开辟成功,则返回一个指向开辟好空间的指针。
- 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
- 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
malloc失败导致对空指针解引用:
int *p = (int*)malloc(INT_MAX);
*p = 5;
free(p);
p = NULL;
记得返回动态开辟的空间地址,别忘了最后释放空间避免内存泄露:
int* get_memory()//也可使用二级指针
int* p = (int*)malloc(40);
//....
return p;
}
int main()
{
int *ptr = get_memory();
//使用
//释放
free(ptr);
ptr = NULL;
return 0;
}
返回栈空间地址问题:
char* Getmemory()
{
const char* a = "hello";//存放在常量区返回后地址还在
return (char*)a;
}
char* Getmemory()
{
char a[] = "hello";//栈区空间返回后被销毁
return a;
}
int main()
{
char* p = Getmemory();
printf("%s", p);
return 0;
}
int* test()
{
int a = 10;
return &a;
}
int main()
{
int*p = test();
//printf("hehe\n");
printf("%d\n", *p);
return 0;
}
这段代虽然访问了被销毁的空间,但依然能正确输出,这可能是由于编译器并未对数据进行清理的缘故,依然是一段错误代码,当你在打印前加上个printf函数,它开辟的栈帧会建立在销毁的test函数上,可能就导致数据被篡改了。
free
free函数用来释放动态开辟的内存。
- 如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
- 如果参数 ptr 是NULL指针,则函数什么事都不做。
int* p = (int*)malloc(40);
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 5; i++)
{
*p = i;
p++;
}
//释放
//在释放的时候,p指向的不再是动态内存空间的起始位置
free(p);
p = NULL;
注意释放时需要记录起始位置的地址。
calloc
void* calloc(size_t num, size_t size)
- 函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为0。
- 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
realloc
void* realloc(void *ptr, size_t size)
对已经动态开辟的空间进行扩容(缩容),如果第一个参数为NULL则作用类似于malloc。
如果扩容失败则返回NULL,所以扩容前最好将原地址保存起来。
内存开辟
1.
栈区(
stack
):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结
束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是
分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返
回地址等。
2.
堆区(
heap
):一般由程序员分配释放, 若程序员不释放,程序结束时可能由
OS
回收 。分
配方式类似于链表。
3.
数据段(静态区)(
static
)存放全局变量、静态数据。程序结束后由系统释放。
4.
代码段:存放函数体(类成员函数和全局函数)的二进制代码
柔性数组
在c99中,结构体的最后一个成员可以设置成柔性数组(否则不知道对齐数)。
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;
有些编译器会报错无法编译可以改成:
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
- 结构中的柔性数组成员前面必须至少一个其他成员。(结构体大小是编译时分配,而柔性数组是动态开辟的)
- sizeof 返回的这种结构大小不包括柔性数组的内存。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
使用柔性数组:
struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 4);//连续开辟
if (ps == NULL)
return 1;
ps->n = 10;
ps->s = 5.5f;
for (int i = 0; i < 4; i++)
{
scanf("%d", &ps->arr[i]);
}
struct S*ptr = (struct S*)realloc(ps, sizeof(struct S)+10*sizeof(int));
if (ptr == NULL)
{
return 1;
}
else
{
ps = ptr;
}
free(ps);
ps = NULL;
return 0;
}
使用指针:
struct S
{
int n;
float s;
int *arr;//指针——>动态开辟
};
int mian()
{
struct S*ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
return 1;
ps->n = 100;
ps->s = 5.5f;
int* ptr = (int*)malloc(4 * sizeof(int));
if (ptr == NULL)
{
return 1;
}
else
{
ps->arr = ptr;
}
//使用
int i = 0;
for (i = 0; i < 4; i++)
{
scanf("%d", &(ps->arr[i]));
}
realloc(ps->arr, 10*sizeof(int));
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
}
优点
首先,在内存分配中,连续分配的内存有利于减少内存碎片,提高访问速度。
其次,当你在函数中对结构体及其指针成员进行两次动态分配后,可能会只释放了结构体而忘了释放成员在堆上开辟的空间,造成内存泄露。