c语言malloc函数的用法,malloc怎么使用，请举例说明，谢谢！

c语言malloc函数的用法,malloc怎么使用，请举例说明，谢谢！详细介绍

本文目录一览： C语言中的malloc函数的使用？

C语言中malloc是动态内存分配函数。
函数原型：void *malloc(unsigned int num_bytes);
参数：num_bytes 是无符号整型，用于表示分配的字节数。
返回值：如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。void* 表示未确定类型的指针，void *可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用户是用这段空间来存储什么类型的数据（比如是char还是int或者...）
功能：分配长度为num_bytes字节的内存块
注意：当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。
实例：
#include"stdio.h"
#include"malloc.h"//malloc()函数被包含在malloc.h里面
int main(void)
{
char*a=NULL;//声明一个指向a的char*类型的指针
a=(char*)malloc(100*sizeof(char));//使用malloc分配内存的首地址，然后赋值给a
if(!a)//如果malloc失败，可以得到一些log
{
perror("malloc");
return-1;
}
sprintf(a,"%s","HelloWorld\n");//"HelloWorld\n"写入a指向的地址
printf("%s\n",a);//输出用户输入的数据
free(a);//释放掉使用的内存地址
return0;//
}
第一，表示没有什么问题。
第二这样分配的内存空间不是连续的5个int型内存。内存没有类型，只能说你分配了5个int类型长度的内存空间。
和int a[5]有差异。一个的内存使用在堆里，一个在栈里
1.没有错误.不过分配了就要赋给某个指针,不然,这块内存就memory leak了.
int *ptr = (int *)malloc(5*sizeof(int));
2.是5个连续的int型大小的内存,和int a[5]不一样.因为类型不一样.但其在内存表示上是一样的,都是5个Int型空间.

C语言中的malloc函数用法)？

用变量表示长度，想对数组的大小作动态说明，这是错误的。但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种问题，用数组的办法很难解决。为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数可以按需要动态地分配内存空间，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。
常用的内存管理函数有以下三个：
1. 分配内存空间函数malloc
调用形式：
(类型说明符*)malloc(size)
功能：在内存的动态存储区中分配一块长度为"size"字节的连续区域。函数的返回值为该区域的首地址。
“类型说明符”表示把该区域用于何种数据类型。
(类型说明符*)表示把返回值强制转换为该类型指针。
“size”是一个无符号数。
例如：
pc=(char *)malloc(100);
表示分配100个字节的内存空间，并强制转换为字符数组类型，函数的返回值为指向该字符数组的指针，把该指针赋予指针变量pc。
2. 分配内存空间函数 calloc
calloc 也用于分配内存空间。
调用形式：
(类型说明符*)calloc(n,size)
功能：在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。
(类型说明符*)用于强制类型转换。
calloc函数与malloc 函数的区别仅在于一次可以分配n块区域。
例如：
ps=(struet stu*)calloc(2,sizeof(struct stu));
其中的sizeof(struct stu)是求stu的结构长度。因此该语句的意思是：按stu的长度分配2块连续区域，强制转换为stu类型，并把其首地址赋予指针变量ps。
2. 释放内存空间函数free
调用形式：
free(void*ptr);
功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，它指向被释放区域的首地址。被释放区应是由malloc或calloc函数所分配的区域。
【例】分配一块区域，输入一个学生数据。
main()
{
struct stu
{
int num;
char *name;
char sex;
float score;
} *ps;
ps=(struct stu*)malloc(sizeof(struct stu));
ps->num=102;
ps->name="Zhang ping";
ps->sex='M';
ps->score=62.5;
printf("Number=%d\nName=%s\n",ps->num,ps->name);
printf("Sex=%c\nScore=%f\n",ps->sex,ps->score);
free(ps);
}
本例中，定义了结构stu，定义了stu类型指针变量ps。然后分配一块stu大内存区，并把首地址赋予ps，使ps指向该区域。再以ps为指向结构的指针变量对各成员赋值，并用printf输出各成员值。最后用free函数释放ps指向的内存空间。整个程序包含了申请内存空间、使用内存空间、释放内存空间三个步骤，实现存储空间的动态分配。
可以用，两者的区别在于，一个是创建静态内存，一个是动态内存。
只是你要做成服务程序或者有基于这个数组的算法时，别忘记用完p之后要free()，并且让p=(int*)NULL
void main()
{
int a[5],*p ;
p=a;
p=(int*)malloc(5*sizeof(int)) ;
//此处这样写有问题，根本就没必要动态分配内存，因为p指向的是一个数组，数组已经定义，也就是已经分配了空间，纯粹多余
for(int i=0;i<5;i++) scanf("%d",p++);
free(p);
}
malloc（）是是在内存的动态存储区中分配一个长度为size的连续空间。
当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为
NULL并执行相应的操作
malloc分配的内存是位于堆中的,并且没有初始化内存的内容使用了malloc没有使用free，注意释放内存
p=(int *)malloc(5*sizeof(int)) /*这个也就是说P指向的连续5个空间的首地址*/
for(i=0;i<5;i++) scanf("%d",p++);
用法没 问题，但是问题是。。你最后p指向了 数组的最后，。。
你还要调整p，scanf("%d",(p+i))多好啊
动态申请1维数组，int *a;
a=(int *)malloc(5*sizeof(int)) ;
for(i=0;i<5;i++) scanf("%d",p++);
以后你就可以引用a数组了
第二种用法有点问题，应该这样改一下：
int *arr = (int *)malloc(5 * sizeof(int));
int *p = arr;
int i;
for (i = 0; i < 5; ++i)
scanf("%d", p++);
...
...
free(arr);
C语言中malloc是动态内存分配函数。
函数原型：void *malloc(unsigned int num_bytes)。
参数：num_bytes 是无符号整型，用于表示分配的字节数。
注意：当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。关于该函数的原型，在以前malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。
实现malloc的方法：
首先我们要确定所采用的数据结构。一个简单可行方案是将堆内存空间以块的形式组织起来，每个块由meta区和数据区组成，meta区记录数据块的元信息（数据区大小、空闲标志位、指针等等）。
数据区是真实分配的内存区域，并且数据区的第一个字节地址即为malloc返回的地址 。

C语言calloc的用法？

void *calloc(size_t nobj, size_t size)；calloc函数为由nobj个长度为size的对象组成的数组分配内存，并返回指向分配区域的指针；若无法满足要求，则返回NULL。该空间的初始长度为0字节
void *malloc(size_t size)；malloc函数为长度size的对象分配内存，并返回指向分配区域的指针；若无法满足要求，则返回NULL。该函数不对分配的内存区域进行初始化。
void *realloc(void *p, size_t size)；realloc函数将p指向的对象的长度修改为size个字节。如果新分配的内存比原来内存大，则内存的内容保持不变，增加的空间不进行初始化。如果新分配的内存比原来的内存小，则分配内存单元不初始化，realloc函数返回指向新分配空间的指针；若无法满足要求，则返回NULL。在这种情况下，原来指针p指向的单元内容保持不变。
str = (char*)calloc(10,sizeof(char));是什么意思？
是分配10个大小为char，也就是十个字节的内存给str，地址类型是char指针

C语言 关于malloc的用法

函数的形参指针，对指针进行sizeof操作，只能得到指针在内存中所占的大小，而不是指针所指向的内容的大小。
在这个函数中，你若想知道*a1和*a2的长度，确保字符串结尾存在'\0'后，可以用strlen得到字符串长度。如果字符串中没有结束符，只能在函数的参数中带入字符串的长度，在函数中直接分配空间。
问题出在你的sizeof使用错误，sizeof输入的是指针变量，而指针变量的大小在32位下统一是4个字节，因此x和y总会是4。如果a1和a2均指向字符串的话，可以用strlen去获取字符串长度（注意字符串是有'\0'来做结束符），另外你的a3应该定义成指针变量，如char *a3，这样才可以a3=(char *)malloc(z);
char *a3;x=strlen(a1);y=strlen(a2);z=x+y+1;a3=(char *)malloc(z);
malloc是分配动态数组存储空间的函数，引用它必需包含头文件"malloc.h"或"stdlib.h"，malloc的作用是分配指定字节个内存空间，并返回该内存空间的首地址，但在赋值前必需进行强制类型转换。至于之后p其实就可以作为普通数组进行使用了，你的程序中少了free(p);，要将malloc的空间进行释放。

C语言中怎么使用malloc函数

malloc 是用来申请内存的。
一般都是申请一定个数的某个类型空间，做数组使用。
比如
int *p = (int *)malloc(sizeof(int ) * 10);
就是分配了10个int的空间。
使用后 要记得free(p);

C语言：谁能教教我malloc怎样使用

原型 void * malloc(int size);
参数推荐使用sizeof()确定数据类型的大小，这样写出的程序可移植性比较好；
返回的指针要强制转换成需要是数据类型；
对返回值一定要判断，避免分配失败造成写内存出错。
举例，创建一个有10个元素的整型数组：
int *p;
p = NULL;
p = (int *)malloc(sizeof(int) * 10);
if (!p) {
perror("malloc fail");
exit(1);
}
..........
我能想到的也就是这些了，请方家指正。
范例：
/* MALLOC.C: This program allocates memory with
* malloc, then frees the memory with free.
*/
#include

/* For _MAX_PATH definition */

#include

#include

void main( void )

{

char *string;

/* Allocate space for a path name */

string = malloc( _MAX_PATH );

// In a C++ file, explicitly cast malloc's return. For example,

// string = (char *)malloc( _MAX_PATH );

if( string == NULL )

printf( "Insufficient memory available\n" );

else

{

printf( "Memory space allocated for path name\n" );

free( string );

printf( "Memory freed\n" );

}

}

结果输出：

Memory space allocated for path name

Memory freed

返回值类型为 void *,调用格式为：malloc(size),size的类型为unsigned int 。

malloc函数用来分配size个字节的存储区，返回一个指向存储区首地址的基类型为void的地址。若没有足够的内存单元供分配，函数返回空（NULL）

通过调用malloc函数所分配的动态存储单元中没有确定的初值，这个存储单元也没有名字，吸能靠指针来引用它。

例：int *pi;

float *pf;

pi=(int *)malloc(2);

pf=(float *)malloc(4);

因为malloc函数的返回的地址为void *,在调用函数时，必须延用强制类型转换将其转换为所需要的类型。括号中的*号代表返回的是指针类型的

C语言中malloc函数的使用方法

用于申请空间，调用格式，
（指针所指对象的数据类型*）malloc（sizeof(指针所指对象的数据类型)*个数）
malloc函数的参数是你需要在堆上分配的内存的大小，单位是字节。函数返回一个void*型的变量，就是分配的内存的起始地址，需要转换为你所需要的类型的指针。如果分配失败，会返回NULL，这要在分配结束后先检查。最后，使用完毕内存别忘了free。
例：分配10个整形变量的内存空间。
int * start;
if ( (start=(int *)molloc(sizeof(int)*10)) == NULL )
{
printf("Momery is not enough!\a");
exit(1);
}
.../* 使用你申请的内存 */
free(start);

C语言中的malloc()函数

　　原型：extern void *malloc(unsigned int num_bytes);
　　头文件：#include

或 #include

(注意：alloc.h 与 malloc.h 的内容是完全一致的。)

　　功能：分配长度为num_bytes字节的内存块

　　说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

　　当内存不再使用时，应使用free()函数将内存块释放。

　　使用方法举例：

#include

#include

int main() { char *p; p=(char *)malloc(100); if(p) printf("Memory Allocated at: %x/n",p); else printf("Not Enough Memory!/n"); free(p); return 0; }

#include

#include

int

main()

{

int

*p

,*q

;

int

i;

q=p=(int

*)malloc(12);//q,p是同时指向同一块空间,就是说只申请了一块内存

for(i=0;i<3;i++)

{

scanf("%d",p++);

}

for(i=0;i<3;q++,i++)//而你又改变了q,p的指向,释放的空间就不是原先申请的内存了

{

printf("%d\n",*q);

}

// free(p);

free(q);//而这里却是释放两块内存

return

0;

}

我想这么改

#include

#include

int

main()

{

int

*p

,*q

;

int

i

;

q=p=(int

*)malloc(12)

;

for(i=0;i<3;i++)

{

scanf("%d",p++);

}

p=q;

for(i=0;i<3;q++,i++)

{

printf("%d\n",*q);

}

free(p);

}

头文件：#include

char *p;

p=(char *)malloc(100);

需要包含头文件：

＃i nclude

或

＃i nclude

函数声明(函数原型)：

void *malloc(int size);

说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如：

int *p;

p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int);

或：

int* parr;

parr = new int [100]; //返回类型为 int* 类型(整数型指针)，分配大小为 sizeof(int) * 100;

而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。

int* p;

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

第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。

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

int* p = (int *) malloc (1);

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

malloc 也可以达到 new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。

比如想分配100个int类型的空间：

int* p = (int *) malloc ( sizeof(int) * 100 ); //分配可以放得下100个整数的内存空间。

另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。

除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

malloc怎么使用，请举例说明，谢谢！

malloc 原型：extern void *malloc(unsigned int num_bytes);
用法：#include

或#include

功能：分配长度为num_bytes字节的内存块

说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

当内存不再使用时，应使用free()函数将内存块释放。

malloc的语法是：指针名=（数据类型*）malloc（长度）,（数据类型*）表示指针.

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。

动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。本文简单介绍动态内存分配函数malloc（）及几种实现方法。

1． 简介

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。

2． 函数说明

C语言的动态存储管理由一组标准库函数实现，其原型在标准文件

里描述，需要用这些功能时应包含这个文件。与动态存储分配有关的函数共有四个，其中就包括存储分配函数malloc（）。函数原型是：void *malloc (size_t n);这里的size_t是标准库里定义的一个类型，它是一个无符号整型。这个整型能够满足所有对存储块大小描述的需要，具体相当于哪个整型由具体的C系统确定。malloc的返回值为(void *)类型（这是通用指针的一个重要用途），它分配一片能存放大小为n的数据的存储块，返回对应的指针值；如果不能满足申请（找不到能满足要求的存储块）就返回NULL。在使用时，应该把malloc的返回值转换到特定指针类型，赋给一个指针。

注意，虽然这里的存储块是通过动态分配得到的，但是它的大小也是确定的，同样不允许越界使用。例如上面程序段分配的块里能存n个双精度数据，随后的使用就必须在这个范围内进行。越界使用动态分配的存储块，尤其是越界赋值，可能引起非常严重的后果，通常会破坏程序的运行系统，可能造成本程序或者整个计算机系统垮台。

下例是一个动态分配的例子：

#include

#include

main()

{

int count,*array; /*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址*/

count=100;

if((array=(int *)malloc(10*sizeof(int))) == NULL)

{

printf("不能成功分配存储空间。");

exit(1);

}

for(count=0;count<10;count++) /*给数组赋值*/

array[count]=count;

for(count=0;count<10;count++) /*打印数组元素*/

printf("%2d",array[count]);

}

上例中动态分配了10个整型存储区域，然后进行赋值并打印。例中if((array=(int *) malloc (10*sizeof(int)))==NULL)语句可以分为以下几步：

1）分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针

2）把此整型指针地址赋给array

3）检测返回值是否为NULL

char *p,

p=(char*)malloc(char)

是申请一个动态单元的函数

原形是void * malloc(单元大小)

返回值是一个指针，是个地址

单元大小可以是2，3，4，随便写，与具体环境有关

例如，struct num{int i,long j;}*p;

你就可以这样写p=(struct num* )malloc(sizeof(struct student))就是分配一个大小为sizeof(struct student )的单元给指针p

申请动态内存

char型的：

char* ch = (char*)malloc(sizeof(char)*n)

里面n为你要申请的字节个数

int型的：

int* nNum = (int*)malloc(sizeof(int)*n)

里面n为你要申请的每四字节的个数。

用完后最后要free（ch）掉你申请的内存空间，以免内存泄漏

malloc使用须要包括头文件：

#include 'stdlib.h'

例如：

int *p;

p = new int; /返回类型为int* 类型(整数型指针)。分配大小为 sizeof(int);

或：

int* parr;

parr = new int [100]; //返回类型为 int* 类型(整数型指针)。分配大小为 sizeof(int) * 100;

而 malloc 则必须由我们计算要字节数，而且在返回后强行转换为实际类型的指针。

int* p;

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

扩展资料：malloc 函数返回的是 void * 类型。

对于C++，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。

所以必须通过 (int *) 来将强制转换。而对于C，没有这个要求，但为了使C程序更方便的移植到C++中来，养成强制转换的习惯。

在Linux中可以有这样：malloc(0),这是因为Linux中malloc有一个下限值16Bytes，注意malloc(-1)是禁止的；但是在某些系统中是不允许malloc(0)的。

在规范的程序中我们有必要按照这样的格式去使用malloc及free:

type *p;

if(NULL == (p = (type*)malloc(sizeof(type))))

/*请使用if来判断,这是有必要的*/

{

perror("error...");

exit(1);

}

.../*其它代码*/

free(p);

p = NULL;/*请加上这句*/