C语言的动态内存分配

C语言的动态内存分配

malloc

void* malloc(size_t size);

malloc将为用户分配size_t字节个内存，并且返回内存分配的地址，如果分配失败，那么返回0

int* pa=(int*)malloc(4);

pa是分配好的内存地址，4是要分配的大小

如果内存分配失败，那么pa=0

unsigned x;
std::cin>>x;

int* p=(int*)malloc(x*sizeof(int));//malloc返回值是void*类型，需要强制类型转换
if(p==nullptr)
	cout<<"内存分配失败"<<endl;
else {
    p[0]=1;
    p[1]=2;
    p[3]=3;
}

calloc

void* calloc(size_t count, size_t size);

calloc将为用户分配count乘size_t字节个内容，并且返回内存分配的地址，如果分配失败，那么返回0

int *pa = calloc(1,4);

pa是分配好的内存地址，1是要分配的元素个数，4是要分配的每个元素的大小

如果内存分配失败，那么pa=0

calloc会将分配好的内存区域设置为0

int* p=(int*)calloc(x,sizeof(int));

realloc

void* realloc(void* _Block, size_t_Size);

realloc将为用户重新分配内存，_Block是用户已经分配好的内存，Size是要求重新分配的大小，函数返回重新分配后的内存。会将数据拷贝到重新分配的内存。

int* pa=(int*)malloc(4);
pa=(int*)realloc(pa,8);

pa是重新分配后的内存的地址，8是重新分配后的大小

如果内存分配失败，那么pa=0

free

void free(void* _Block);

_Block是你要释放的内存地址。

int* pa=(int*)malloc(4);
free(pa);

pa所占用的内存被释放

new

数据类型* 指针变量名称=new 数据类型；

int* pa=new int;

数据类型* 指针变量名称=new 数据类型[数量]；

int* pa=new int[5]; //分配一段能够存放5个int变量类型的内存空间

分配失败pa返回0

delete

delete 指针; //释放new分配的内存

delete[] 指针; //释放用new数据类型[]分配的内存

int* pa=new int;
delete pa;

int*pb=new int[5];
delete[] pb;

动态内存分配的风险

悬挂指针

• 释放后再使用（可能报错可能不报）

int* p=new int[5];
delete p;
p[2]=250;

• 重复释放（可能报错可能不报）

int* p=new int;
int* pold=p;
delete p;
delete pold;

内存碎片问题

频繁的申请和释放小块内存会造成内存碎片,虽然原则上还有内存可以使用,但是实际上由于剩余内存碎片化的存在,使得我们无法分配新的内存,当然,现在也不必太担心这样的情况,因为new和delete背后的算法会尽力规避这个风险,并且现在我们的虚拟内存也足够大,但是如果是嵌入式开发,或者要求较高的开发,就要注意这个问题,我们也可以自己来控制我们的内存分配,但这个是比较高阶的操作

补充：复制内存

void* memcpy(vid* _Dst, const void* _Src, size_t _Size);

memcpy可以将_Src区域的内存复制到_Dst区域，复制的长度为_Size字节

int a[5]{1001,1002,1003,1004,1005};
int* p=new int[5];
memcpy( p , a , 5*sizeof(int) );

补充知识：设置内存

void* memset(void* _Dst,int val,size_t _Size);

0<val<0xFF（一个字节）

int* p=new int[100];
memset( p , 0 , 100*sizeof(int) );

memset( p ,0 ); // 全设置为0
memset(p,0xff); // 全设置为-1