2010年9月28日星期二

malloc函数

malloc函数

百科名片

本词条主要介绍 malloc 函数

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

目录

函数简介
函数声明
函数的工作机制
举例说明

函数简介

  原型:extern void *malloc(unsigned int num_bytes);
  头文件:在TC2.0中可以用malloc.h或 alloc.h (注意:alloc.h 与 malloc.h 的内容是完全一致的),而在Visual C++6.0中可以用malloc.h或者stdlib.h。
  功能:分配长度为num_bytes字节的内存块
  返回值:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。当内存不再使用时,应使用free()函数将内存块释放。
  说明:关于该函数的原型,在旧的版本中malloc返回的是char型指针,新的ANSIC标准规定,该函数返回为void型指针,因此必要时要进行类型转换。
  相关函数:callocreallocfree、_alloca

函数声明

  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得到指针,在其它操作上保持一致。
  对其做一个特例补充
  char *ptr;
  if ((ptr = (char *)malloc(0)) == NULL)
  puts("Got a null pointer");
  else
  puts("Got a valid pointer");
  此时得到的是Got a valid pointer。把0赋给malloc能得到一个合法的指针。

函数的工作机制

  malloc函数的实质体现在,它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时,它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后,将该内存块一分为二(一块的大小与用户请求的大小相等,另一块的大小就是剩下的字节)。接下来,将分配给用户的那块内存传给用户,并将剩下的那块(如果有的话)返回到连接表上。调用free函数时,它将用户释放的内存块连接到空闲链上。到最后,空闲链会被切成很多的小内存片段,如果这时用户申请一个大的内存片段,那么空闲链上可能没有可以满足用户要求的片段了。于是,malloc函数请求延时,并开始在空闲链上翻箱倒柜地检查各内存片段,对它们进行整理,将相邻的小空闲块合并成较大的内存块。

举例说明

  举例1:(在Visual C++ 6.0中运行通过)
  #include
  #include
  int main()
  {
  int i,j;
  int *array=NULL;
  scanf("%d",&i);
  array=(int*)malloc(i*sizeof(int));
  for(j=0;j
  scanf("%d",&array[j]);
  for(j=0;j
  printf("%d\n",array[j]);
  free(array);
  array=NULL;
  return 0;
  }
  举例2:(在TC2.0中运行通过) 
  /*malloc.c*/
  #include
  #include
  main()
  {
  char *p;
  clrscr(); /*clear screen*/
  p=malloc(100);
  if(p)
  printf("Memory Allocated at: %x",p);
  else
  printf("Not Enough Memory!\n");
  free(p);
  getchar();
  return 0;
  }

CPU 读取内存数据过程,地址总线,数据总线,控制总线

CPU在运作时,读取内存数据,首先要指定存储单元的地址。就是要确实读取哪段数据,就想大街上找人,首先要确定他在哪栋房子里。

(注意:另外,CPU读写数据时还有指明,它要对哪个器件进行操作,何种操作,是从中读取数据,还是向里写入数据。)

CPU要进行数据的读写,必须和外部器件(标准的说法是芯片)进行信息下3类交互

存储单元的地址(地址信息)

器件的选择,读or写 (控制信息)

读写的数据 (数据信息)



CPU 是以电信号的方式,以导线传输到存储器的芯片中

CPU连接芯片的导线,成为总线

根据传输的信息不同,总线分为三类,地址总线,控制总线,数据总线。如图

CPU 读取内存数据过程,地址总线,数据总线,控制总线 - 【墨Ю】 - 墨




读取流程:

1,CPU通过地址线将地址信息3发出

2,CPU通过控制线发出内存读命令,选中存储器芯片,并通知它,将要从中读取数据。

3,存储器将3号单元中的数据 8 通过数据线送入 CPU



写入流程:(将26写入单元3)

1,CPU通过地址线将地址信息3发出。

2,CPU通过地址线发出内存写命令,选中存储器芯片,并通知它,要其写入数据

3,CPU通过数据线将数据26送入内存3单元中



地址总线

其中CUP通过地址总线要寻址,指定存储单元。

可见地址总线上能传送多少个不同的信息,CPU就可以对多少个存储单元进行寻址。

有10根地址总线,就能传送10位二进制数据,也就是2的10次方 。最小位0,最大为1023。

也就是 2(n) = 最大传输 n = 多少地址总线

CPU地址总线的宽带决定了CPU的寻址能力



数据总线

CPU与内存或其他器件直接爱你数据传达是通过数据总线来进行的。

数据总线的宽度决定了CPU和外界的数据传输速度。

8根数据总线一次可以传送8位二进制数据。

16根数据总线一次可以穿2个字节。



控制总线

CPU对外部部件的控制时通过控制总线来进行的。 控制总线是个总称,控制总线是有不同的控制线来集合的。

有多少根控制总线,就意味着 CPU 提供了对外部器件的多少种控制。

so 数据总线的宽带决定了CPU对外部部件的控制能力。



内存读或写时,是有几根控制线综合发出的,其中一根称为“读信号输出”的控制线负责由CPU向外传送读信号。

有一根称为“读信号输出”的控制线负责传送写信号。

内存分配详解、指针与数组[C++][内存管理]

程序员们经常编写内存管理程序,往往提心吊胆。如果不想触雷,唯一的解决办法就是发现所有潜伏的地雷并且排除它们,躲是躲不了的。本文的内容比一般教科书的要深入得多,读者需细心阅读,做到真正地通晓内存管理。

内存分配方式

(1)从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static变量。
(2)在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。
(3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。

常见的内存错误及其对策

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误,通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状,时隐时现,增加了改错的难度。有时用户怒气冲冲地把你找来,程序却没有发生任何问题,你一走,错误又发作了。 常见的内存错误及其对策如下:

* 内存分配未成功,却使用了它

编程新手常犯这种错误,因为他们没有意识到内存分配会不成功。常用解决办法是,在使用内存之前检查指针是否为NULL。如果指针p是函数的参数,那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存,应该用if(p==NULL) 或if(p!=NULL)进行防错处理。

* 内存分配虽然成功,但是尚未初始化就引用它

犯这种错误主要有两个起因:一是没有初始化的观念;二是误以为内存的缺省初值全为零,导致引用初值错误(例如数组)。内存的缺省初值究竟是什么并没有统一的标准,尽管有些时候为零值,我们宁可信其无不可信其有。所以无论用何种方式创建数组,都别忘了赋初值,即便是赋零值也不可省略,不要嫌麻烦。

* 内存分配成功并且已经初始化,但操作越过了内存的边界

例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中,循环次数很容易搞错,导致数组操作越界。

* 忘记了释放内存,造成内存泄露

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足,你看不到错误。终有一次程序突然死掉,系统出现提示:内存耗尽。

动态内存的申请与释放必须配对,程序中malloc与free的使用次数一定要相同,否则肯定有错误(new/delete同理)。

* 释放了内存却继续使用它

有三种情况:

(1)程序中的对象调用关系过于复杂,实在难以搞清楚某个对象究竟是否已经释放了内存,此时应该重新设计数据结构,从根本上解决对象管理的混乱局面。

(2)函数的return语句写错了,注意不要返回指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁。

(3)使用free或delete释放了内存后,没有将指针设置为NULL。导致产生“野指针”。

【规则1】用malloc或new申请内存之后,应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。

【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

【规则3】避免数组或指针的下标越界,特别要当心发生“多1”或者“少1”操作。

【规则4】动态内存的申请与释放必须配对,防止内存泄漏。

【规则5】用free或delete释放了内存之后,立即将指针设置为NULL,防止产生“野指针”。

指针与数组的对比

C++/C程序中,指针和数组在不少地方可以相互替换着用,让人产生一种错觉,以为两者是等价的。

数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。数组名对应着(而不是指向)一块内存,其地址与容量在生命期内保持不变,只有数组的内容可以改变。

指针可以随时指向任意类型的内存块,它的特征是“可变”,所以我们常用指针来操作动态内存。指针远比数组灵活,但也更危险。

下面以字符串为例比较指针与数组的特性

1 修改内容

下例中,字符数组a的容量是6个字符,其内容为hello。a的内容可以改变,如a[0]= 'x'。指针p指向常量字符串"world"(位于静态存储区,内容为world),常量字符串的内容是不可以被修改的。从语法上看,编译器并不觉得语句 p[0]= 'x'有什么不妥,但是该语句企图修改常量字符串的内容而导致运行错误。

#include<iostream.h>

void main()

{

char a[] = "hello";

a[0] = 'x';
cout
<< a << endl;
char *p = "world"; // 注意p指向常量字符串
p[0] = 'x'; // 编译器不能发现该错误
cout << p << endl;
}

2 内容复制与比较

不能对数组名进行直接复制与比较。下例中,若想把数组a的内容复制给数组b,不能用语句 b = a ,否则将产生编译错误。应该用标准库函数strcpy进行复制。同理,比较b和a的内容是否相同,不能用if(b==a) 来判断,应该用标准库函数strcmp进行比较。

语句p = a 并不能把a的内容复制指针p,而是把a的地址赋给了p。要想复制a的内容,可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存,再用strcpy进行字符串复制。同理,语句if(p==a) 比较的不是内容而是地址,应该用库函数strcmp来比较。

// 数组…

char a[] = "hello";

char b[10];

strcpy(b, a); // 不能用 b = a;

if(strcmp(b, a) == 0) // 不能用 if (b == a)

// 指针…

int len = strlen(a);

char *p = (char *)malloc(sizeof(char)*(len+1));

strcpy(p,a); // 不要用 p = a;

if(strcmp(p, a) == 0) // 不要用 if (p == a)

3 计算内存容量

用运算符sizeof可以计算出数组的容量(字节数)。下例(a)中,sizeof(a)的值是12(注意别忘了' ')。指针p指向a,但是 sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数,相当于sizeof(char*),而不是p所指的内存容量。 C++/C语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针。下例(b)中,不论数组a的容量是多少,sizeof(a)始终等于sizeof(char *)。

示例(a)


char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12字节
cout<< sizeof(p) << endl; // 4字节


示例(b)

void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4字节而不是100字节
}

函数数组指针

笔者在开发某软件过程中遇到这样一个问题,前级模块传给我二进制数据,输入参数为 char* buffer和 int length,buffer是数据的首地址,length表示这批数据的长度。数据的特点是:长度不定,类型不定,由第一个字节(buffer[0])标识该数据的类型,共有256(28 )种可能性。我的任务是必须对每一种可能出现的数据类型都要作处理,并且我的模块包含若干个函数,在每个函数里面都要作类似的处理。若按通常做法,会写出如下代码:

void MyFuntion( char* buffer, int length )
{
    __int8 nStreamType = buffer[0];

    switch( nStreamType )
    {
       case 0:
           function1();
           break;
       case 1:
       ......
       case 255:
           function255();
           break;
     }
}

如果按照这种方法写下去,那么在我的每一个函数里面,都必须作如此多的判断,写出的代码肯定很长,并且每一次处理,都要作许多次判断之后才找到正确的处理函数,代码的执行效率也不高。针对上述问题,我想到了用函数指针数组的方法解决这个问题。

  函数指针的概念,在潭浩强先生的C语言程序设计这本经典的教程中提及过,在大多数情况下我们使用不到,也忽略了它的存在。函数名实际上也是一种指针,指向函数的入口地址,但它又不同于普通的如int*、double*指针,看下面的例子来理解函数指针的概念:
int funtion( int x, int y );
void main ( void )
{
   int (*fun) ( int x, int y );
   int a = 10, b = 20;
   function( a, b );
   fun = function;
   (*fun)( a, b );
    ……
}
  语句1定义了一个函数function,其输入为两个整型数,返回也为一个整型数(输入参数和返回值可为其它任何数据类型);语句3定义了一个函数指针,与int*或double*定义指针不同的是,函数指针的定义必须同时指出输入参数,表明这是一个函数指针,并且*fun也必须用一对括号括起来;语句6将函数指针赋值为funtion,前提条件是*fun和function的输入参数和返回值必须保持一致。语句5直接调用函数function(),语句7是调用函数指针,二者等效。

  当然从上述例子看不出函数指针的优点,目的主要是想引出函数指针数组的概念。我们从上面例子可以得知,既然函数名可以通过函数指针加以保存,那们也一定能定义一个数组保存若干个函数名,这就是函数指针数组。正确使用函数指针数组的前提条件是,这若干个需要通过函数指针数组保存的函数必须有相同的输入、输出值。

这样,我工作中所面临的问题可以解决如下:

首先定义256个处理函数(及其实现)。

void funtion0( void );
……..
void funtion255(void );

其次定义函数指针数组,并给数组赋值。
void (*fun[256])(void);

fun[0] = function0;
…….
fun[255] = function();
最后,MyFunction()函数可以修改如下:

void MyFuntion( char* buffer, int length )
{
    __int8 nStreamType = buffer[0];
    (*fun[nStreamType])();
}

  只要2行代码,就完成了256条case语句要做的事,减少了编写代码时工作量,将nStreamType作为数组下标,直接调用函数指针,从代码执行效率上来说,也比case语句高。假如多个函数中均要作如此处理,函数指针数组更能体现出它的优势。