电子发烧友App
C语言程序设计中，动态内存分配如何实现，需要注意哪些问题？
1、动态内存分配用malloc函数，他的函数原型
void * malloc (size_t size);
malloc有一个参数size，表示需要申请的内存空间大小，单位是字节。
- 分配的内存空间连续，如果没有空闲内存，可能分配失败
- 返回值为void*类型，也就是没有确定具体的数据类型，由用户自己决定，也就是需要强制数据类型转换
// 动态内存分配
#include < stdio.h >
#include < stdlib.h >
#define SIZE 5
void display(int *p, int n){
int i;
for(i = 0; i < n; i ++){
printf("%5dn", p[i]);
}
}
int main(){
int *p = (int *)malloc(SIZE * sizeof(int));
if(!p) exit(-1);
for(int i = 0; i < SIZE; i ++){
p[i] = i;
}
display(p, SIZE);
free(p);
return 0;
}
案例中，分配了一个大小为SIZEsizeof(int)个字节的内存空间，强制转换为int类型，并由指针p指向该内存空间。
sizeof(int *); // 求出int *类型变量占据的内存大小
sizeof(int);// 求出int类型变量占据的内存大小
int *p; sizeof(*p); // 求出指针p所存放的地址占据的内存大小
假设int类型变量占据4个字节的内存，那么总共分配了20个字节的内存空间。
2、malloc分配的内存属于堆内存
所谓堆内存，他的生命周期与进程相同。
int* initArr(){
int *p = (int *)malloc(SIZE * sizeof(int));
if(!p) exit(-1);
for(int i = 0; i < SIZE; i ++){
p[i] = i;
}
return p;
}
int main(){
int *p = initArr();
display(p, SIZE);
free(p);
return 0;
}
案例中，虽然动态内存是在函数initArr中申请到的，它的作用域应该是函数内部，但是在主函数main中依然可以使用这个内存，正是由于该内存属于堆内存，生命周期与进程相同，不会因为函数调用结束而释放。
同样的，正是因为该内存没有释放，才可以在函数display中继续使用。
3、内存释放函数free，函数原型
void free(void *ptr)
由于malloc申请的内存属于堆内存，生命周期较长，所以在使用完之后，如果后面的程序再也用不到该内存，就应该提前将其释放，释放malloc申请的内存用free函数。
free函数有一个参数，指向将要释放的内存块，所以是一个指针，没有返回值。
上面的案例中，在主函数返回之前，内存使用完之后，就直接释放了该内存。需要注意的是，如果后面还需要继续使用该内存，切不可提前释放。
int main(){
int *p = initArr();
free(p);
display(p, SIZE);
return 0;
}
这必然是一个错误的示例，如果提前释放了该内存，后面就找不到相应的内存，也就不能继续对该空间进行操作。
free(p);
p=NULL;
在释放动态内存之后，最好将原来的指针设置为空，防止指针p成为野指针被使用。
4、malloc数组的溢出
#define SIZE 5
#define N 7
int* initArr(){
int *p = (int *)malloc(SIZE * sizeof(int));
if(!p) exit(-1);
for(int i = 0; i < N; i ++){
p[i] = i;
}
return p;
}
int main(){
int *p = initArr();
display(p, N);
free(p);
return 0;
}
案例打印的结果如下
0
1
2
3
4
5
6
是的，你没有看错，本来申请的是5个元素空间，这里打印了7个元素，而且没有报错。这就是mallo函数申请的内存与静态数组的区别，malloc申请的内存属于堆内存，虽然指定的内存只有5个元素大小，但是后面依然可以访问。
这是一个非常危险的操作，因为你不知道越界之后，对越界后的内存修改，会不会影响其他程序。
int a[5];
for(int i=0; i < 6; i ++){
a[i]=i;
}
在这个静态数组中，必然会报错，程序执行到后面的时候，可能执行失败，因为已经越界。静态数组存储在栈内存中，属于动态存储区，他不允许越界操作。
5、malloc函数可开辟的最大空间
malloc开辟的空间属于堆内存，静态数组属于栈内存，两者的最大容量存在差异。
#define SIZE 102400000000000
int *p = (int *)malloc(SIZE * sizeof(int));
if(!p) exit(-1);
在你的计算机上也许可以成功申请到这么大的内存，但是如果用静态数组，这个操作很可能失败。
#define SIZE 102400000000000
int a[SIZE];
a[0]=0;
printf("%dn", a[0]);
一般情况下，静态数组允许申请的最大连续空间，小于动态数组允许申请的最大连续空间。
6、calloc函数
void *calloc(size_t nitems, size_t size)
calloc函数与malloc函数功能相同，不同点是：calloc函数会对所有元素进行初始化，初始化为0。
calloc函数有两个参数，第一个参数是将要申请的元素个数，第二个参数是每个元素的内存大小。
int* initArr2(){
int *p = (int *)calloc(SIZE, sizeof(int));
if(!p) exit(-1);
return p;
}
int main(){
int *p = initArr2();
display(p, N);
free(p);
return 0;
}
案例中，申请了一个动态内存，并对该内存进行初始化，所有元素都是0，因此，在不给每个元素赋值的情况下，打印出来的全部是0。
calloc函数分配的内存也是堆内存，他与malloc相同，存在的问题也相同。
7、realloc函数
尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。
void *realloc(void *ptr, size_t size)
第一个参数表示指向已经申请到的动态内存块，如果为空指针，则会重新分配一个新内存块。第二个参数表示新内存块的大小，可以比原来的内存块大，也可以比原来内存块小。
int* initArr3(int *p){
int *pnew = (int *)realloc(p, (SIZE + SIZE) * sizeof(int));
if(!pnew) exit(-1);
for(int i = 0; i < N; i ++){
pnew[i] = i;
}
return pnew;
}
int main(){
int *p = initArr3(NULL);
display(p, N);
free(p);
return 0;
}
传入的参数为NULL，可以重新分配一个内存块。
int main(){
int *p = initArr2();
display(p, N);
int *pnew = initArr3(p);
display(pnew, N);
// display(p, N);//此时原来的数组已经不存在
free(pnew);
return 0;
}
传入一个已经指向的内存，在原来的基础上进行扩大或者缩小，返回新内存的首地址。原来的内存将会被释放。
realloc函数与malloc、calloc函数类似，也会存在malloc函数类似的问题。
以上是C语言动态申请内存的相关内容，动手尝试验证一下上述问题。
工商网监
评论