C语言的内存分配.docx

C语言的内存分配.docx

《C语言的内存分配.docx》由会员分享，可在线阅读，更多相关《C语言的内存分配.docx（20页珍藏版）》请在冰豆网上搜索。

C语言的内存分配

在任何程序设计环境及语言中，内存管理都十分重要。

在目前的计算机系统或嵌入式系统中，内存资源仍然是有限的。

因此在程序设计中，有效地管理内存资源是程序员首先考虑的问题。

第1节主要介绍内存管理基本概念，重点介绍C程序中内存的分配，以及C语言编译后的可执行程序的存储结构和运行结构，同时还介绍了堆空间和栈空间的用途及区别。

第2节主要介绍C语言中内存分配及释放函数、函数的功能，以及如何调用这些函数申请/释放内存空间及其注意事项。

3.1内存管理基本概念

3.1.1　C程序内存分配

1．C程序结构

下面列出C语言可执行程序的基本情况（Linux2.6环境/GCC4.0）。

[root@localhostCtest]#lstest-l    //test为一个可执行程序

-rwxr-xr-x 1rootroot4868Mar2608:

10test

[root@localhostCtest]#filetest //此文件基本情况

test:

ELF32-bitLSBexecutable,Intel80386,version1（SYSV）,

forGNU/Linux2.2.5,dynamicallylinked（usessharedlibs）,notstripped

[root@localhostCtest]#sizetest  //此二进制可执行文件结构情况

//代码区静态数据/全局初始化数据区　未初始化数据区　十进制总和　十六进制总和文件名

text  data        bss   dec   hex filename

906   284         4   1194   4aa test

可以看出，此可执行程序在存储时（没有调入到内存）分为代码区（text）、数据区（data）和未初始化数据区（bss）3个部分。

（1）代码区（textsegment）。

存放CPU执行的机器指令（machineinstructions）。

通常，代码区是可共享的（即另外的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。

代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。

另外，代码区还规划了局部变量的相关信息。

（2）全局初始化数据区/静态数据区（initializeddatasegment/datasegment）。

该区包含了在程序中明确被初始化的全局变量、静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。

例如，一个不在任何函数内的声明（全局数据）：

int  maxcount=99;

使得变量maxcount根据其初始值被存储到初始化数据区中。

staticmincount=100;

这声明了一个静态数据，如果是在任何函数体外声明，则表示其为一个全局静态变量，如果在函数体内（局部），则表示其为一个局部静态变量。

另外，如果在函数名前加上static，则表示此函数只能在当前文件中被调用。

（3）未初始化数据区。

亦称BSS区（uninitializeddatasegment），存入的是全局未初始化变量。

BSS这个叫法是根据一个早期的汇编运算符而来，这个汇编运算符标志着一个块的开始。

BSS区的数据在程序开始执行之前被内核初始化为0或者空指针（NULL）。

例如一个不在任何函数内的声明：

long sum[1000];

将变量sum存储到未初始化数据区。

图3-1所示为可执行代码存储时结构和运行时结构的对照图。

一个正在运行着的C编译程序占用的内存分为代码区、初始化数据区、未初始化数据区、堆区和栈区5个部分。

（点击查看大图）图3-1　C程序的内存布局

（1）代码区（textsegment）。

代码区指令根据程序设计流程依次执行，对于顺序指令，则只会执行一次（每个进程），如果反复，则需要使用跳转指令，如果进行递归，则需要借助栈来实现。

代码区的指令中包括操作码和要操作的对象（或对象地址引用）。

如果是立即数（即具体的数值，如5），将直接包含在代码中；如果是局部数据，将在栈区分配空间，然后引用该数据地址；如果是BSS区和数据区，在代码中同样将引用该数据地址。

（2）全局初始化数据区/静态数据区（DataSegment）。

只初始化一次。

（3）未初始化数据区（BSS）。

在运行时改变其值。

（4）栈区（stack）。

由编译器自动分配释放，存放函数的参数值、局部变量的值等。

其操作方式类似于数据结构中的栈。

每当一个函数被调用，该函数返回地址和一些关于调用的信息，比如某些寄存器的内容，被存储到栈区。

然后这个被调用的函数再为它的自动变量和临时变量在栈区上分配空间，这就是C实现函数递归调用的方法。

每执行一次递归函数调用，一个新的栈框架就会被使用，这样这个新实例栈里的变量就不会和该函数的另一个实例栈里面的变量混淆。

（5）堆区（heap）。

用于动态内存分配。

堆在内存中位于bss区和栈区之间。

一般由程序员分配和释放，若程序员不释放，程序结束时有可能由OS回收。

之所以分成这么多个区域，主要基于以下考虑：

一个进程在运行过程中，代码是根据流程依次执行的，只需要访问一次，当然跳转和递归有可能使代码执行多次，而数据一般都需要访问多次，因此单独开辟空间以方便访问和节约空间。

临时数据及需要再次使用的代码在运行时放入栈区中，生命周期短。

全局数据和静态数据有可能在整个程序执行过程中都需要访问，因此单独存储管理。

堆区由用户自由分配，以便管理。

下面通过一段简单的代码来查看C程序执行时的内存分配情况。

相关数据在运行时的位置如注释所述。

//main.cpp

inta=0;    //a在全局已初始化数据区

char*p1;    //p1在BSS区（未初始化全局变量）

main（）

{

intb;    //b在栈区

chars[]="abc"; //s为数组变量，存储在栈区，

//"abc"为字符串常量，存储在已初始化数据区

char*p1，p2;  //p1、p2在栈区

char*p3="123456"; //123456\0在已初始化数据区，p3在栈区

staticintc=0；  //C为全局（静态）数据，存在于已初始化数据区

//另外，静态数据会自动初始化

p1=（char*）malloc（10）;//分配得来的10个字节的区域在堆区

p2=（char*）malloc（20）;//分配得来的20个字节的区域在堆区

free（p1）;

free（p2）;

}

2．内存分配方式

在C语言中，对象可以使用静态或动态的方式分配内存空间。

静态分配：

编译器在处理程序源代码时分配。

动态分配：

程序在执行时调用malloc库函数申请分配。

静态内存分配是在程序执行之前进行的因而效率比较高，而动态内存分配则可以灵活的处理未知数目的。

静态与动态内存分配的主要区别如下：

静态对象是有名字的变量，可以直接对其进行操作；动态对象是没有名字的变量，需要通过指针间接地对它进行操作。

静态对象的分配与释放由编译器自动处理；动态对象的分配与释放必须由程序员显式地管理，它通过malloc（）和free两个函数（C++中为new和delete运算符）来完成。

以下是采用静态分配方式的例子。

inta=100;

此行代码指示编译器分配足够的存储区以存放一个整型值，该存储区与名字a相关联，并用数值100初始化该存储区。

以下是采用动态分配方式的例子。

p1=（char*）malloc（10*sizeof（int））;//分配得来得10*4字节的区域在堆区

此行代码分配了10个int类型的对象，然后返回对象在内存中的地址，接着这个地址被用来初始化指针对象p1，对于动态分配的内存唯一的访问方式是通过指针间接地访问，其释放方法为：

free（p1）;

3.1.2　栈和堆的区别

前面已经介绍过，栈是由编译器在需要时分配的，不需要时自动清除的变量存储区。

里面的变量通常是局部变量、函数参数等。

堆是由malloc（）函数（C++语言为new运算符）分配的内存块，内存释放由程序员手动控制，在C语言为free函数完成（C++中为delete）。

栈和堆的主要区别有以下几点：

（1）管理方式不同。

栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。

（2）空间大小不同。

栈是向低地址扩展的数据结构，是一块连续的内存区域。

这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，当申请的空间超过栈的剩余空间时，将提示溢出。

因此，用户能从栈获得的空间较小。

堆是向高地址扩展的数据结构，是不连续的内存区域。

因为系统是用链表来存储空闲内存地址的，且链表的遍历方向是由低地址向高地址。

由此可见，堆获得的空间较灵活，也较大。

栈中元素都是一一对应的，不会存在一个内存块从栈中间弹出的情况。

（3）是否产生碎片。

对于堆来讲，频繁的malloc/free（new/delete）势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。

对于栈来讲，则不会存在这个问题。

（4）增长方向不同。

堆的增长方向是向上的，即向着内存地址增加的方向；栈的增长方向是向下的，即向着内存地址减小的方向。

（5）分配方式不同。

堆都是程序中由malloc（）函数动态申请分配并由free（）函数释放的；栈的分配和释放是由编译器完成的，栈的动态分配由alloca（）函数完成，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行申请和释放的，无需手工实现。

（6）分配效率不同。

栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：

分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行。

堆则是C函数库提供的，它的机制很复杂，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大的空间，如果没有足够大的空间（可能是由于内存碎片太多），就有需要操作系统来重新整理内存空间，这样就有机会分到足够大小的内存，然后返回。

显然，堆的效率比栈要低得多。

3.1.3　Linux数据类型大小

在Linux操作系统下使用GCC进行编程，目前一般的处理器为32位字宽，下面是/usr/include/limit.h文件对Linux下数据类型的限制及存储字节大小的说明。

/*Wedon'thave#include_next.  DefineANSIforstandard32-bitwords. */

/*Theseassume8-bit'char's,16-bit'shortint's,  and32-bit'int'sand'longint's. */

1．char数据类型

char类型数据所占内存空间为8位。

其中有符号字符型变量取值范围为?

128～127，无符号型字符变量取值范围为0～255。

其限制如下：

/*Numberofbitsina'char'. */

# defineCHAR_BIT 8          //所占字节数

/*Minimumandmaximumvaluesa'signedchar'canhold. */  //有符号字符型范围

# defineSCHAR_MIN （-128）

# defineSCHAR_MAX 127

/*Maximumvaluean'unsignedchar'canhold. （Minimumis0.） */ //无符号字符型范围

# defineUCHAR_MAX 255

/*Minimumandmaximumvaluesa'char'canhold. */

# ifdef__CHAR_UNSIGNED__

#  defineCHAR_MIN 0

#  defineCHAR_MAX UCHAR_MAX

# else

#  defineCHAR_MIN SCHAR_MIN

#  defineCHAR_MAX SCHAR_MAX

# endif

2．shortint数据类型

shortint类型数据所占内存空间为16位。

其中有符号短整型变量取值范围为?

32768～32767，无符号短整型变量取值范围为0～65535。

其限制如下：

/*Minimumandmaximumvaluesa'signedshortint'canhold. */ //有符号短整型范围

# defineSHRT_MIN （-32768）

# defineSHRT_MAX 32767

/*Maximumvaluean'unsignedshortint'canhold. （Minimumis0.） *///无符号短整型范围

# defineUSHRT_MAX 65535

3．int数据类型

int类型数据所占内存空间为32位。

其中有符号整型变量取值范围为?

2147483648～2147483647，无符号型整型变量取值范围为0～4294967295U。

其限制如下：

/*Minimumandmaximumvaluesa'signedint'canhold. */  //整形范围

# defineINT_MIN （-INT_MAX-1）     

# defineINT_MAX 2147483647

/*Maximumvaluean'unsignedint'canhold. （Minimumis0.） */ //无符号整形范围

# defineUINT_MAX 4294967295U

4．longint数据类型

随着宏__WORDSIZE值的改变，longint数据类型的大小也会发生改变。

如果__WORDSIZE的值为32，则longint和int类型一样，占有32位。

在LinuxGCC4.0-i386版本中，默认情况下__WORDSIZE的值为32。

其定义如下：

//comefrom/usr/include/bits/wordsize.h

#define__WORDSIZE 32

在64位机器上，如果__WORDSIZE的值为64，long　int类型数据所占内存空间为64位。

其中有长整型变量取值范围为-9223372036854775808L～3372036854775807L，无符号长整型变量取值范围为0～18446744073709551615UL。

其限制如下：

/*Minimumandmaximumvaluesa'signedlongint'canhold. */ //有符号长整形范围

# if__WORDSIZE==64

#  defineLONG_MAX 9223372036854775807L

# else

#  defineLONG_MAX 2147483647L

# endif

# defineLONG_MIN （-LONG_MAX-1L）

/*Maximumvaluean'unsignedlongint'canhold. （Minimumis0.） *///无符号长整形范围

# if__WORDSIZE==64

#  defineULONG_MAX 18446744073709551615UL

# else

#  defineULONG_MAX 4294967295UL

# endif

5．longlongint数据类型

在C99中，还定义了longlongint数据类型。

其数据类型限制如下：

# ifdef__USE_ISOC99

/*Minimumandmaximumvaluesa'signedlonglongint'canhold. *///无符号长长整形范围

#  defineLLONG_MAX 9223372036854775807LL

#  defineLLONG_MIN （-LLONG_MAX-1LL）

/*Maximumvaluean'unsignedlonglongint'canhold. （Minimumis0.） *///有符号长长整形范围

#  defineULLONG_MAX 18446744073709551615ULL

# endif/*ISOC99*/

3.1.4　数据存储区域实例

此程序显示了数据存储区域实例，在此程序中，使用了etext、edata和end3个外部全局变量，这是与用户进程相关的虚拟地址。

在程序源代码中列出了各数据的存储位置，同时在程序运行时显示了各数据的运行位置，图3-2所示为程序运行过程中各变量的存储位置。

图3-2　函数运行时各数据位置

主函数源代码如下：

[root@localhostlinux_app]#catmem_add.c

#include

#include

#include

#include

externvoidafunc（void）;

externetext,edata,end;

intbss_var;                               //未初始化全局数据存储在BSS区

intdata_var=42;                           //初始化全局数据存储在数据区

#defineSHW_ADR（ID,I）printf（"the%8s\tisatadr:

%8x\n",ID,&I）; //打印地址宏

intmain（intargc,char*argv[]）

{

char*p,*b,*nb;

printf（"Adretext:

%8x\tAdredata%8x\tAdrend%8x\t\n",&etext,&edata,&end）;

printf（"\ntextLocation:

\n"）;

SHW_ADR（"main",main）;             //查看代码段main函数位置

SHW_ADR（"afunc",afunc）;          //查看代码段afunc函数位置

printf（"\nbssLocation:

\n"）;

SHW_ADR（"bss_var",bss_var）;     /查看BSS段变量位置

printf（"\ndatalocation:

\n"）;

SHW_ADR（"data_var",data_var）;    /查看数据段变量

printf（"\nStackLocations:

\n"）; 

afunc（）;

p=（char*）alloca（32）;             //从栈中分配空间

if（p!

=NULL）

{

SHW_ADR（"start",p）;

SHW_ADR（"end",p+31）;

}

b=（char*）malloc（32*sizeof（char））;  //从堆中分配空间

nb=（char*）malloc（16*sizeof（char））;  //从堆中分配空间

printf（"\nHeapLocations:

\n"）;

printf（"theHeapstart:

%p\n",b）;   //堆起始位置

printf（"theHeapend:

%p\n",（nb+16*sizeof（char）））;//堆结束位置

printf（"\nbandnbinStack\n"）;

SHW_ADR（"b",b）;       //显示栈中数据b的位置

SHW_ADR（"nb",nb）;      //显示栈中数据nb的位置

free（b）;         //释放申请的空间，以避免内存泄漏

free（nb）;        //释放申请的空间，以避免内存泄漏

}

子函数源代码如下：

voidafunc（void）

{

staticintlonglevel=0;         //静态数据存储在数据段中

int     stack_var;                //局部变量，存储在栈区

if（++level==5）

{

return;

}

printf（"stack_varisat:

%p\n",&stack_var）;

//     SHW_ADR（"stack_varinstacksection",stack_var）;

//     SHW_ADR（"Levelindatasection",level）;

afunc（）;

}

函数运行结果如下：

[root@localhostlinux_app]#gcc-omem_addmem_add.c //编译

[root@localhostlinux_app]#./mem_add    //运行结果

Adretext:

8048702      Adredata 8049950     Adrend 804995c

textLocation:

the    main    isatadr:

8048418

the   afunc    isatadr:

8048611

bssLocation:

the bss_var    isatadr:

8049958

datalocation:

thedata_var    isatadr:

804994c

StackLocations:

thestack_varinstacksection   isatadr:

bfbf6c44

theLevelindatasection        isatadr:

8049954

thestack_varinstacksection   isatadr:

bfbf6c24

theLevelindatasection        isatadr:

8049954

thestack_varinstacksection   isatadr:

bfbf6c04

theLevelindatasection        isatadr:

8049954

thestack_varinstacksection   isatadr:

bfbf6be4

theLevelindatasection        isatadr:

8049954

the   start    isatadr:

bfbf6c74

the     end    isatadr:

bfbf6cf0

HeapLocations:

theHeapstart:

0x8453008

theHeapend:

0x8453040

bandnbinStack