内存的动态分配

来源：互联网发布：cisco 端口聚合编辑：程序博客网时间：2024/05/29 16:09

void *malloc(unsigned int)函数包含在<stdlib.h>头文件中，void * //泛型指针，其返回值为指针可以付给任何类型

malloc(1000); malloc ( n ); (float *)malloc(n*sizeof(float)); (int *)malloc(n*sizeof( int ));等等都代表开辟了一个内存空间

将该空间的首地址赋予指针，注意其类型一致例如：

char *p;
p= (char *)malloc(n*sizeof(char));

int* p;

p = (int*) malloc (sizeof(int)*128);

//分配128个（可根据实际需要替换该数值）整型存储单元，

//并将这128个连续的整型存储单元的首地址存储到指针变量p中

double*pd=(double *) malloc (sizeof(double)*12);

//分配12个double型存储单元，

//并将首地址存储到指针变量pd中

*******************************************************************************************************************

第一、malloc 函数返回的是 void * 类型。对于C++，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。而对于C，没有这个要求，但为了使C程序更方便的移植到C++中来，建议养成强制转换的习惯。

第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。如果你写成：

代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容被改写。

*******************************************************************************************************************

正常片段：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedefstruct data_type{ 
intage; 
charname[20]; 
} data; 
data *bob; 
bob = (data *) malloc( sizeof(data) );
if( bob != NULL ) {
bob->age = 22;
strcpy( bob->name,"Robert" ); 
printf("%s is %d years old\n", bob->name, bob->age );
}else{
printf("malloc error!\n");
exit(1);
} 
free( bob );
bob = NULL;

内存泄漏实例：

?
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <malloc.h>
#define MAX 100000000
int main(void) 
{ 
int*a[MAX]; 
inti; 
for( i=0; i<MAX; i++ ) {
a[i] = (int*)malloc( MAX );
}
return0; 
}

例2：

?
1
2
3
4
5
6
7
8
9
10
11
#include "stdio.h"
#include "malloc.h" //malloc()函数被包含在malloc.h里面
int main(void) // 主函数程序的入口 
{ 
char*a; //声明一个指向char的指针 
a=(char*)malloc(100*sizeof(char));//使用malloc分配内存的首地址，然后赋值给a 
gets(a);//从用户那里得到数据，把数据放入a中 
printf("%s\n",a);//输出用户输入的数据 
free(a);//释放掉使用的内存地址，就是因为可以释放内存地址才被称为动态内存分配 
return0; //返回，退出 
}

/* void *malloc(unsigned int)

void * //泛型指针，其返回值为指针可以付给任何类型
int main(void)
{
char *p=malloc(1000); //开辟的堆空间
p[0]; //所开辟空间的第一个字节
p[1]; //第二个字节
int *q=malloc(1000);
q[0]; //100z字节的前四个字节
q[1]; //第五至第八字节
}
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
char *p=malloc(1000);
if(p == NULL) //相当于 if(!p)
perror("malloc");
exit(-1); //
free(p); //将开辟堆对空间释放，该空间可以再次被申请
return 0;

}
//编译系统会根据变量的声明来开辟内存空间

栈空间静态内存分配其大小编译时决定
堆空间动态内存分配其大小运行时决定
动态静态
大小运行是2决定大小编译时决定
程序员分配编译器分配
手动释放自动释放*/
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int i=0,n;
while(i++<100)
{
char *p;
scanf("%d",&n);
p=malloc(n+1);//在程序运行中可以随时调整空间的大小
if(p == NULL)
{
perror("malloc");
exit(-1);
}
scanf("%s",p);
printf("%s\n",p);
free(p); //一次开辟利用结束后立即释放，
}
return 0;
}
******************************************************
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int i=0,n;
while(i++<100)
{
scanf("%d",&n);
char *p;
p= (char *)malloc(n*sizeof(char));
if(!p)
{
perror("malloc");
exit(-1);
}
scanf("%s",p);
printf("%s\n",p);
free(p);
}
return 0;
}
================================================
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int i=0,n;
while(i++<100)
{
char *p; //此句和下一句调换位置则不能编译，，真心不懂
scanf("%d",&n);
p=(char *)malloc(n*sizeof(char));
if(p==NULL)
{
perror("malloc");
exit(-1);
}
scanf("%s",p);
printf("%s\n",p);
free(p);
}
return 0;

}