12.4 分配内存:malloc()和free()
前面讨论的存储类别有一个共同之处:在确定用哪种存储类别后,根据已制定好的内存管理规则,将自动选择其作用域和存储器。然后,还有更灵活的选择,即用库函数分配和管理内存。
所有程序都必须预留足够的内存来存储程序来存储程序使用的数据。这些内存中有些是自动分配的。例如,以下声明:
float x;
char place[] = "Dancing Oxen Creek";
为一个float类型的值和一个字符串预留了足够的内存,或者可以显式指定分配一定数量的内存:
int places[100];
该声明预留了100个内存位置,每个位置都用于存储一个int类型的值。声明还为内存提供了一个标识符。因此,可以使用x或place识别数据。
回忆一下,静态数据在程序载入内存时分配,而自动数据在程序执行块时分配,并在程序离开该块时销毁。
C能做的不止这些。可以在程序运行时分配内存。主要的工具是malloc()函数,该函数接受一个参数:所需的内存字节数。malloc()会找到合适的空闲内存块,这样的内存是匿名的。也就是说,malloc()分配内存,但是不会为其赋名。然而,它确实返回动态分配内存块的首字节地址。
因此,可以把该地址赋给一个指针变量,并使用指针访问这块内存。因为char表示1字节,malloc()的返回类型通常被定义为指向char的指针。
然而,从ANSI C标准开始,C使用一个新的类型:指向void的指针。该类型相当于一个“通用指针”。malloc()函数可用于返回指向数组的指针、指向结构的指针,所以通常该函数的返回值会被强制转换为匹配的类型。在ANSI C中,应该坚持使用强制类型转换,提高代码的可读性。然而,把指向void的指针赋给任意类型的指针完全不用考虑匹配的问题。如果malloc()分配内存失败,将返回空指针。
试着用malloc()创建一个数组。除了用malloc()在程序运行时请求一块内存,还需要一个指针记录这块内存的位置。例如:
double *ptd;
ptd = (double *)malloc( 30 * sizeof(double) );
以上代码为30个double类型的值请求内存空间,并设置ptd指向该位置。注意,指针ptd被声明为指向一个double类型,而不是指向内含30个double类型值的块。数组名是该数组首元素的地址。因此,如果让ptd指向这个块的首元素,便可像使用数组名一样使用它。也就是说,可以使用表达式ptd[0]访问该块的首元素,依次类推。根据前面所需的知识,可以使用数组名来表示指针,也可以用指针来表示数组。
现在,有3种创建数组的方法。
*声明数组时,用常量表达式表示数组的维度,用数组名访问数组的元素。可以用静态内存或自动内存创建这种数组。
*声明变长数组(C99新增的特性)时,用变量表达式表示数组的维度,用数组名访问数组的元素。具有这种特性的数组只能在自动内存中创建。
*声明一个指针,调用malloc(),将其返回值赋给指针,使用指针访问数组的元素。该指针可以是静态的或自动的。
使用第2种方法和第3种方法可以创建动态数组(dynamic array)。这种数组和普通数组不同,可以在程序运行时选择数组的大小和分配内存。
例如,假设n是一个整型变量。在C99之前,不能这样做:
double item[n]; //C99之前;n不允许是变量*/
但是,可以这样做:
ptd = (double *)malloc( n * sizeof(double) ); //可以
如你所见,这比变长数组更灵活。
通常,malloc()要与free()配套使用。free()函数的参数是之前malloc()返回的地址,该函数释放之前malloc()分配的内存。因此,动态分配内存的存储期是从调用malloc()分配内存到调用free()释放内存为止。设想malloc()和free()管理着一个内存池。每次调用malloc()分配内存给程序使用,每次调用free()把内存归返内存池中,这样便可重复使用这些内存。free()的参数应该是一个指针,指向由malloc()分配的一块内存。不能用free()释放通过其他方式分配的内存。malloc()和free()原型都在stdlib.h头文件中。
使用malloc(),程序可以在运行时才确定数组大小。
可以调用exit()函数结束程序,其原型在stdlib.h中。EXIT_FAILURE的值也被定义在stdlib.h中。标准提供了两个返回值以保证在所有操作系统中都能正常工作:EXIT_SUCCESS(或者,相当于0)表示普通的程序结束,EXIT_FAILURE表示程序的异常终止。一些操作系统(包括UNIX、Linux和Windows)还接受一些表示其他运行错误的整数值。
/* dyn_arr.c -- dynamically allocated array */
#include <stdio.h>
#include <stdlib.h> /* for malloc(), free() */
int main(void)
{
double * ptd;
int max;
int number;
int i = 0;
puts("What is the maximum number of type double entries?");
if (scanf("%d", &max) != 1)
{
puts("Number not correctly entered -- bye.");
exit(EXIT_FAILURE);
}
ptd = (double *) malloc(max * sizeof (double));
if (ptd == NULL)
{
puts("Memory allocation failed. Goodbye.");
exit(EXIT_FAILURE);
}
/* ptd now points to an array of max elements */
puts("Enter the values (q to quit):");
while (i < max && scanf("%lf", &ptd[i]) == 1)
++i;
printf("Here are your %d entries:\n", number = i);
for (i = 0; i < number; i++)
{
printf("%7.2f ", ptd[i]);
if (i % 7 == 6)
putchar('\n');
}
if (i % 7 != 0)
putchar('\n');
puts("Done.");
free(ptd);
return 0;
}
/* 输出:
*/
在C中,不一定要使用强制类型转换(double *),但是在C++中必须使用。所以,使用强制类型转换更容易把C程序转换为C++程序。
malloc()可能分配不到所需的内存。在这种情况下,该函数返回空指针,程序结束:
ptd = (double *) malloc(max * sizeof (double));
if (ptd == NULL)
{
puts("Memory allocation failed. Goodbye.");
exit(EXIT_FAILURE);
}
如果程序成功分配,便可把ptd视为一个有max个元素的数组名。
free()函数只释放其参数指向的内存块。一些操作系统在程序结束时会自动释放动态分配的内容,但是有些系统不会。为保险起见,请使用free(),不要依赖操作系统来清理。
使用动态数组有什么好处?从本例来看,使用动态数组给程序带来了更多灵活性。
12.4.1 free()的重要性
静态内存的数量在编译时是固定的,在程序运行期间也不会改变。自动变量使用的内存数量在程序执行期间自动增加或减少。但是动态分配的内存数量只会增加,除非用free()进行释放。例如:
...
int main( ){
double glad[2000];
int i;
...
for( i = 0; i < 1000; i++ ){
gobble( glad, 2000 );
}
...
}
void gobble( double ar[], int n ){
double *temp = (double *)malloc( n * sizeof(double) );
.../* free( temp ); //假设忘记使用free() */
}
如上面代码所示,遗漏了free()。当函数结束时,作为自动变量的指针temp也会消失。但是它所指向的16000字节却仍然存在。由于temp指针已被销毁,所以无法访问这块内存,它也不能被重复使用,因为代码中没有调用free()释放这块内存。
第2次调用gobble()时,它又创建了指针temp,并调用malloc()分配了16000字节的内存。第1次分配的16000字节内存已不可用,所以malloc()分配了另外一块16000字节的内存。当函数结束时,该内存块也无法被再次访问和再使用。
循环要执行1000次,所以在循环结束时,内存池中有1600万字节被占用。实际上,也许在循环结束之前就已耗尽所有的内存。这类问题被称为内存泄漏(memory leak)。在函数末尾处调用free()函数可避免这类问题产生。
12.4.2 calloc()函数
分配内存还可以使用calloc(),典型的用法如下:
long *newmem;
newmem = (long *)calloc( 100, sizeof(long) );
和malloc()类似,在ANSI之前,calloc()也返回指向char的指针;在ANSI之后,返回指向void的指针。如果要存储不同的类型,应使用强制类型转换说明符。calloc()函数接受两个无符号整数作为参数(ANSI规定是size_t类型)。第1个参数是所需的存储单元数量,第2个参数是存储单元的大小(以字节为单位)。
用sizeof(long)而不是4,提高了代码的可移植性。这样,在其他long不是4字节的系统中也能正常工作。
calloc()函数还有一个特性:它把块中的所有位都设置为0(注意,在某些硬件系统中,不是把所有位都设置为0来表示浮点值0)。
free()函数也可用于释放calloc()分配的内存。
动态内存分配是许多高级程序设计技巧的关键。有些编译器可能还提供其他内存管理函数,有些可以移植,有些不可以。
12.4.3 动态内存分配和变长数组
变长数组(VLA)和调用malloc()在功能上有些重合。例如,两者都可用于创建在运行时确定大小的数组:
int vlamal(){
int n;
int *pi;
scanf( "%d", &n );
pi = (int *)malloc( n * sizeof(int) );
int ar[n]; //变长数组
pi[2] = ar[2] = -5;
...
}
不同的是,变长数组是自动存储类型。因此,程序在离开变长数组定义所在的块时,变长数组占用的内存空间会被自动释放,不必使用free()。
另一方面,用malloc()创建的数组不必局限在一个函数内访问。另外,free()所用的指针变量可以与malloc()的指针变量不同,但是两个指针必须存储相同的地址。但是,不能释放同一块内存两次。
对多维数组而言,使用变长数组更方便。当然,也可以用malloc()创建二维数组,但是语法比较繁琐。如果编译器不支持变长数组特性,就只能固定二维数组的维度,如下所示:
int n = 5;
int m = 6;
int ar2[n][m]; //n*m的变长数组(VLA)
int (*p2)[6]; //C99之前的写法
int (*p3)[m]; //要求支持变长数组
p2 = (int (*)[6])malloc( n * 6 * sizeof(int) ); //n*6数组
p3 = (int (*)[m])malloc( n * m * sizeof(int) ); //n*m数组(要求支持变长数组)
ar2[1][2] = p2[1][2] = 12;
int (*p2)[6]; //C99之前的写法
表明p2指向一个内含5个int类型值的数组。因此,p2[i]代表一个由6个整数构成的元素,p2[i][j]代表一个整数。
第2个指针声明用一个变量指定p3所指向数组的大小。因此,p3代表一个指向变长数组的指针,这行代码不能在C90标准中运行。
12.4.4 存储类型和动态内存分配
存储类别和动态内存分配有何联系?我们来看一个理想化模型。可以认为程序把它可用的内存分为3部分:一部分供具有外部链接、内部链接和无链接的静态变量使用;一部分供自动变量使用;一部分供动态内存分配。
静态存储类别所用的内存数量在编译时确定,只要程序还在运行,就可访问存储在该部分的数据。该类别的变量在程序开始执行时创建,在程序结束时被销毁。
然而,自动存储类别的变量在程序进入变量定义所在块时存在,在程序离开块时消失。因此,随着程序调用函数和函数结束,自动变量所用的内存数量也相应地增加和减少。这部分的内存通常作为栈来处理,这意味着新创建的变量按顺序加入内存,然后以相反的顺序销毁。
动态分配的内存在调用malloc()或相关函数时存在,在调用free()后释放。这部分的内存由程序员管理,而不是一套规则。所以内存块可以在一个函数中创建,在另一个函数中销毁。正是因为这样,这部分的内存用于动态内存分配会支离破碎。也就是说,未使用的内存块分散在已使用的内存块之间。另外,使用动态内存通常比使用栈内存慢。
总而言之,程序把静态变量、自动变量和动态分配的对象存储在不同的区域。
// where.c -- where's the memory?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int static_store = 30;
const char * pcg = "String Literal";
int main()
{
int auto_store = 40;
char auto_string[] = "Auto char Array";
int * pi;
char * pcl;
pi = (int *) malloc(sizeof(int));
*pi = 35;
pcl = (char *) malloc(strlen("Dynamic String") + 1);
strcpy(pcl, "Dynamic String");
printf("static_store: %d at %p\n", static_store, &static_store);
printf(" auto_store: %d at %p\n", auto_store, &auto_store);
printf(" *pi: %d at %p\n", *pi, pi);
printf(" %s at %p\n", pcg, pcg);
printf(" %s at %p\n", auto_string, auto_string);
printf(" %s at %p\n", pcl, pcl);
printf(" %s at %p\n", "Quoted String", "Quoted String");
free(pi);
free(pcl);
return 0;
}
/* 输出:
*/
如上所示,静态数据(包括字符串字面量)占用一个区域,自动数据占用另一个区域,动态分配的数据占用第3个区域(通常被称为内存堆或自由内存)。