当前位置：文档之家 › 第07章动态内存分配与数据结构

第07章动态内存分配与数据结构

  • 格式：ppt
  • 大小：827.50 KB
  • 文档页数：119

下载文档原格式

  / 119

合集下载

动态内存分配(C语言)

动态内存分配(C语言)

实验报告实验课程名称：动态内存分配算法年12月1日实验报告一、实验内容与要求动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地为之分配内存空间。

在实验中运用了三种基于顺序搜索的动态分区分配算法，分别是1.首次适应算法2.循环首次适应算法3.最佳适应法3.最坏适应法分配主存空间。

二、需求分析本次实验通过C语言进行编程并调试、运行，显示出动态分区的分配方式，直观的展示了首次适应算法循环首次适应算法、最佳适应算法和最坏适应算法对内存的释放和回收方式之间的区别。

首次适应算法要求空闲分区链以地址递增的次序链接，在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止，然后在按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空余分区仍留在空链中。

优点：优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区，为以后到达的大作业分配大的内存空间创造了条件。

缺点：低址部分不断被划分，会留下许多难以利用的、很小的空闲分区即碎片。

而每次查找又都是从低址部分开始的，这无疑又会增加查找可用空闲分区时的开循环首次适应算法在为进程分配内存空间时，不是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲分区。

优点：该算法能使内存中的空闲分区分布得更均匀，从而减少了查找空闲分区时的开销。

最佳适应算法该算法总是把能满足要求、又是最小的空闲分区分配给作业，避免大材小用，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。

缺点：每次分配后所切割下来的剩余部分总是最小的，这样，在存储器中会留下许多难以利用的碎片。

最坏适应算法最坏适应算法选择空闲分区的策略正好与最佳适应算法相反：它在扫描整个空闲分区或链表时，总会挑选一个最大的空闲区，从中切割一部分存储空间给作业使用。

该算法要求，将所有的空闲分区，按其容量以大到小的顺序形成一空闲分区链。

数据结构动态存储管理

数据结构动态存储管理

数据结构动态存储管理动态存储管理是计算机科学中一个重要的主题，它涉及到了如何有效地管理计算机内存的分配和释放。

在计算机程序中，为了存储数据和指令，计算机需要使用内存。

内存是计算机中最宝贵的资源之一，因此有效地管理内存是非常重要的。

本文将介绍几种常见的动态存储管理方法，包括分区分配、固定分区分配、动态分区分配和虚拟内存管理等。

首先，我们来介绍分区分配方法。

这种方法将内存划分为若干个固定大小的区域，每个区域只能分配给一个进程使用。

这种方法简单直接，但是会造成内存空间的浪费。

例如，一个进程可能只需要很小的内存空间，但是由于分区大小固定，它可能被分配一个较大的分区，导致其他进程无法得到足够的内存。

因此，分区分配方法适用于较小型的系统，对于大型系统来说不太适用。

接下来是固定分区分配方法。

这种方法将内存划分为若干个固定大小的区域，每个区域只能分配给一个进程使用。

不同于分区分配方法，固定分区分配方法中的分区大小可以根据不同的进程需求来设置。

这样可以减少内存空间的浪费，但是仍然存在固定分区大小可能不适应所有进程需求的问题。

然后是动态分区分配方法。

这种方法将内存划分为若干个不同大小的区域，每个区域可以根据需要分配给不同的进程使用。

与固定分区分配方法不同，动态分区分配方法中的分区大小可以根据进程需求动态调整。

当一个进程请求内存时，动态分区分配方法会根据可用内存的大小选择一个合适的分区来分配给该进程。

这样可以提高内存利用率，减少内存空间的浪费。

最后是虚拟内存管理方法。

虚拟内存是一种将物理内存和磁盘空间结合起来使用的技术。

虚拟内存管理方法将内存划分为若干个固定大小的页面或帧，并将磁盘空间划分为若干个固定大小的页面或块。

当一个进程请求内存时，虚拟内存管理方法会将页面从磁盘加载到内存中，并将多余的页面移出内存，存放在磁盘空间中。

这样可以实现多个进程共享物理内存，并且可以使得进程能够访问比物理内存更大的地址空间。

虚拟内存管理方法虽然复杂，但是可以提高内存利用率和系统的性能。

第七章动态内存分配

第七章动态内存分配

3. 没有初始化式（initializer），不可对数组初始化。
（选读）
多维数组动态分配： new 类型名[下标表达式1] [下标表达式2]……; 建立一个动态三维数组 float (*cp)[30][20] ; //指向一个30行20列数组的指针 cp=new float [15] [30] [20]; //建立由15个30*20数组组成的数组； 注意cp等效于三维数组名，但没有指出其边界，即最 高维的元素数量，就像指向字符的指针即等效一个字 符串,不要把指向字符的指针，说成指向字符串的指 针。这与数组的嵌套定义相一致。
下面注意如何使用： int main(){ int n; CGoods *pc,*pc1,*pc2; pc=new CGoods(“夏利2000”，10，118000); //调用三参数构造函数 pc1=new CGoods(); //调用缺省构造函数 cout<<“输入商品类数组元素数”<<endl; cin>>n; pc2=new CGoods[n]; //动态建立数组，不能初始化，调用n次缺省构造函数 …… delete pc; delete pc1; delete []pc2; return 0;}
指针使用的几个问题： 1. 动态分配失败。返回一个空指针（NULL），表示 发生了异常，堆资源不足，分配失败。 2. 指针删除与堆空间释放。删除一个指针p （delete p;）实际意思是删除了p所指的目标（变量 或对象等），释放了它所占的堆空间，而不是删除 ｐ本身，释放堆空间后，ｐ成了空悬指针。 3. new()和delete()是可以重载的，它们都是类的 静态成员函数。程序员无需显式声明它为静态的， 系统自动定义为静态的。本教材不讨论new()和 delete()的重载。未重载时，调用全局库操作符 new()。

C程序设计(第2版)第七章习题解答.doc

C程序设计(第2版)第七章习题解答.doc

C程序设计(第2版)第七章习题解答第七章动态内存分配习题一、基本概念与基础知识自测题7.1 填空题7.1.1 C/C++定义了4个内存区间：（1）、（2）、（3）和（4）。

答案：（1）代码区，存放程序代码；（2）全局变量与静态变量区，存放全局变量或对象（包括静态）；（3）局部变量区即栈（stack）区，存放局部变量；（4）自由存储区（free store），即动态存储区或堆（heap）区。

7.1.2 静态定义的变量和对象用标识符命名，称为（1）；而动态建立的称为（2），动态建立对象的初始化是通过（3）实现（4）。

答案：（1）命名对象（2）无名对象（3）初始化式(initializer)（4）显式初始化7.1.3 在用new运算符建立一个三维数组15*30*10时，使用了（1）个下标运算符，对应的用delete运算符注销这个三维数组时使用了（2）个下标运算符。

new返回的指针是指向（3）的指针。

答案：（1）3个（2）1个（3）30行10列的2位数组7.1.4 当动态分配失败，系统采用（1）来表示发生了异常。

如果new返回的指针丢失，则所分配的自由存储区空间无法收回，称为（2）。

这部分空间必须在（3）才能找回，这是因为无名对象的生命期（4）。

答案：（1）返回一个空指针（NULL）（2）内存泄漏（3）重新启动计算机后（4）并不依赖于建立它的作用域7.1.5 按语义的默认复制构造函数和默认复制赋值操作符实现的复制称为（1），假设类对象obj中有一个数据成员为指针，并为这个指针动态分配一个堆对象，如用obj1按成员语义拷贝了一个对象obj2，则obj2对应指针指向（2）。

答案：（1）浅拷贝（2）同一个堆对象7.1.6 单链表的结点包含两个域：（1）和（2）。

使用链表的最大的优点是（3），即使是动态数组也做不到这一点。

答案：（1）数据域（2）指针域（3）用多少空间，开多少空间7.1.7 进入单链表必须通过单链表的（1），如果它丢失则（2），内存也（3），在单链表中进行的查找只能是（4）。

动态内存分配掌握动态内存分配的原理和使用方法

动态内存分配掌握动态内存分配的原理和使用方法

动态内存分配掌握动态内存分配的原理和使用方法动态内存分配是指在程序运行时，根据需要动态地分配内存空间。

相比于静态内存分配，动态内存分配具有灵活性和效率方面的优势。

在程序设计中，正确地掌握动态内存分配的原理和使用方法是非常重要的。

本文将探讨动态内存分配的原理和使用方法，以帮助读者更好地理解并应用于实际开发中。

一、动态内存分配的原理在进行动态内存分配之前，我们首先需要了解几个重要的概念：1. 堆：在程序运行时，动态内存的分配是通过堆来实现的。

堆是一块较大的内存区域，用于存储动态分配的内存。

2. 指针：在动态内存分配过程中，我们通过指针来访问和管理分配的内存。

指针是一个变量，其值是一个地址，指向内存中的某个位置。

3. free store：是动态内存分配的另一种说法，用于表示程序运行时可以动态分配的内存空间。

动态内存分配的原理如下：1. 分配内存：通过调用相关的函数（如malloc、new等），向操作系统申请一块指定大小的内存空间。

2. 绑定指针：将申请到的内存空间的地址与一个指针绑定，以便后续使用。

3. 使用内存：通过指针对动态分配的内存空间进行读取和写入操作。

4. 释放内存：在使用完动态分配的内存后，需要手动释放内存，以便其他程序可以继续使用该内存。

以上就是动态内存分配的基本原理，了解这些原理对于正确和高效地使用动态内存非常重要。

二、动态内存分配的使用方法下面将介绍几种常见的动态内存分配的使用方法，以帮助读者更好地掌握动态内存的使用。

1. 使用malloc/free函数malloc和free是C语言中常用的动态内存分配函数。

malloc函数用于分配一块指定大小的内存空间，free函数用于释放之前分配的内存空间。

示例代码如下：```c#include <stdlib.h>int main(){int* p = (int*)malloc(sizeof(int)); // 分配4个字节大小的内存空间if(p != NULL){*p = 10; // 对动态分配的内存进行写入操作printf("%d\n", *p); // 读取动态分配的内存free(p); // 释放内存空间}return 0;}```2. 使用new/delete运算符在C++中，可以使用new和delete运算符来进行动态内存分配和释放操作。

第7章动态内存分配-2

第7章动态内存分配-2

思考与练习
s data a next b c NULL
设有如上链表，s、p、q为正确定义的指针。现有如 下代码： q=s;s=s->next;p=s; while(p->next) p=p-next; p->next=q; q->next=NULL; 则该程序段的功能是 。 A）首结点成为尾结点 B）尾结点成为首结点 C）删除首结点 D）删除尾结点
tail
p
tail info0
info1 ^ tail
node *createup(){ node *head,*p; Datatype data; head=new node; head->link=NULL; while(cin>>data){ //建立第一个结点 p=new node; p->info=data; p->link= head->link ; //新结点放在原链表前方 head->link=p; //头结点放新结点之前 } return head;}
node *traversal(node *head, Datatype data){ node *p=head->link; while(p!=NULL&&p->info!=data) p=p->link; return p; //p为NULL则未找到
}
返回值为指针p，指向链表中找到的结点。
链表插入算法
•
单链表类型模板
template<typename T>class List{ Node<T> *head,*tail; //链表头指针和尾指针
public:
List(); //构造函数，生成头结点(空链表)

C语言的内存管理及动态内存分配

C语言的内存管理及动态内存分配C语言作为一门广泛应用的编程语言，其内存管理是程序设计中不可忽视的重要方面。

在C语言中，内存的分配和释放是程序员的责任，因此掌握内存管理技术对于编写高效且安全的程序至关重要。

本文将介绍C语言中的内存管理及动态内存分配的相关知识。

一、静态内存分配在C语言中，静态内存分配是指在程序编译时为变量分配固定大小的内存空间。

这些变量的生命周期与程序的运行时间相同，其内存空间在程序启动时分配，在程序结束时释放。

静态内存分配主要用于全局变量和静态局部变量的存储。

全局变量是在函数外部定义的变量，其作用域为整个程序。

全局变量在程序启动时分配内存，在程序结束时释放。

静态局部变量是在函数内部定义的变量，但其生命周期与程序的运行时间相同。

静态局部变量在函数第一次被调用时分配内存，在程序结束时释放。

静态内存分配的优点是简单高效，但其缺点是内存空间固定，无法根据程序运行时的需要进行动态调整。

二、堆和栈除了静态内存分配外，C语言还提供了堆和栈两种动态内存分配方式。

堆是一块较大的内存区域，用于动态分配内存。

程序员可以通过调用malloc函数在堆上分配一块指定大小的内存空间。

堆上分配的内存空间在程序员显式调用free函数释放之前，将一直存在。

栈是一种自动分配和释放内存的机制。

在函数调用时，函数的参数和局部变量会被分配到栈上。

栈上分配的内存空间在函数返回时自动释放，无需程序员显式调用。

堆和栈的区别在于内存的分配方式和生命周期。

堆上分配的内存由程序员手动管理，需要显式地调用free函数进行释放。

而栈上分配的内存由编译器自动管理，无需程序员干预。

三、动态内存分配动态内存分配是指根据程序运行时的需要，动态地分配和释放内存空间。

C语言提供了malloc、calloc和realloc等函数来实现动态内存分配。

malloc函数用于分配指定大小的内存空间，并返回指向该内存空间的指针。

如果分配成功，malloc函数返回一个非空指针；否则，返回空指针。

结构体的使用和动态内存的分配及释放

结构体的使⽤和动态内存的分配及释放结构体什么是结构体？结构体是⽤户根据实际需要⾃⼰定义的复合数据类型。

结构体的出现是为了表⽰⼀些复杂的数据，⽽普通的数据类型⽆法满⾜要求。

结构体的定义：struct Student //struct Student为⼀个复合数据类型,结构体名字为Student,含有三个成员sno,name,age{int sno;char name[20];int age;};//分号不能省实例说明1：#include<stdio.h>#include<string.h>struct Student{int sno;char name[20];int age;};//分号不能省int main(){struct Student st,*pst;pst=&st;/*第⼀种⽅式：结构体变量.成员*/st.sno=99;strcpy(,"李四");//这⾥的strcpy(,"李四")是string类型的赋值st.age=21;printf("%d,%s,%d\n",st.sno,,st.age);/*第⼆种⽅式：pst指向结构体变量中的sno成员，推荐使⽤*/pst->sno=100;//pst->sno等价于(*pst).snostrcpy(pst->name,"王五");pst->age=30;printf("%d,%s,%d\n",pst->sno,pst->name,pst->age);return 0;}实例说明2(通过指针传参(在普通变量的数据类型⼤于4个字节时)可以节省内存和时间，还可以修改成员变量的值)：#include<stdio.h>#include<string.h>struct Student{int sno;char name[20];int age;};void input(struct Student *pst);//前置声明void output(struct Student *pst);int main(){struct Student st;//定义结构体变量st，同时为st分配内存(此时st占28个字节)input(&st);output(&st);return 0;}void output(struct Student *pst)//完成输出{printf("%d %s %d\n",pst->sno,pst->name,pst->age);}void input(struct Student *pst)//完成输⼊{(*pst).sno=100;strcpy(pst->name,"张三");pst->age=21;}注意：1.结构体在定义时并没有分配内存(它只是⼀个模型)，⽽是在定义结构体变量时分配内存。

动态分区分配方式使用的数据结构和分配算法

动态分区分配方式使用的数据结构和分配算法一、引言动态分区分配是操作系统中常用的内存管理方式之一，它的主要目的是为了有效地利用计算机内存资源。

在动态分区分配中，操作系统会将可用内存空间划分为多个大小不同的连续空间，然后按照进程请求的大小来进行动态地分配和释放。

这种方式可以避免内存浪费，提高内存利用率，同时也能够保证进程访问内存时的安全性和稳定性。

二、数据结构在动态分区分配中，需要使用两个重要的数据结构：空闲块链表和已占用块链表。

1. 空闲块链表空闲块链表是指所有未被占用的内存块组成的链表。

每个节点表示一个可用块，并包含以下信息：- 块大小：表示该节点对应空闲块的大小。

- 起始地址：表示该节点对应空闲块在内存中的起始地址。

- 链接指针：指向下一个可用块节点。

2. 已占用块链表已占用块链表是指所有被进程占用的内存块组成的链表。

每个节点表示一个已占用块，并包含以下信息：- 块大小：表示该节点对应已占用块的大小。

- 进程ID：表示该节点对应已占用块所属的进程ID。

- 起始地址：表示该节点对应已占用块在内存中的起始地址。

- 链接指针：指向下一个已占用块节点。

三、分配算法动态分区分配中常用的算法有“首次适应算法”、“最佳适应算法”、“最差适应算法”等。

1. 首次适应算法首次适应算法是指从空闲块链表头开始，依次查找第一个能够满足请求大小的空闲块，并将其分配给进程。

这种方式可以快速地找到满足条件的空闲块，但可能会留下一些无法利用的小碎片。

2. 最佳适应算法最佳适应算法是指从所有可用空闲块中选择大小最合适的空闲块进行分配。

这种方式可以尽可能地利用内存资源，但需要遍历所有可用空闲块，效率较低。

3. 最差适应算法最差适应算法是指从所有可用空闲块中选择大小最大的空闲块进行分配。

这种方式可以尽可能地避免留下碎片，但也可能导致大量内存浪费。

四、动态分区分配的优缺点动态分区分配方式具有以下优点：- 可以动态地分配和释放内存，避免了内存浪费。

《动态分配内存》课件

内存优化
由于游戏需要在各种设备和配置上运行，因此优化内存使用至关重要。通过动态内存分配，可以更有效地管理内存，避免内存泄漏和性能问题。
BIG DATA EMPOWERS TO CREATE A NEWERA
动态内存分配的性能优化
缓存对齐是一种优化技术，通过将数据结构或对象在内存中按一定规则排列，使其在物理内存中的地址与缓存行大小对齐，从而减少缓存未命中的概率，提高数据访问速度。
总结词：动态内存分配函数详细描述：calloc()函数用于在运行时动态分配内存。与malloc()不同的是，calloc()会初始化所分配的内存为0。它根据所需的元素数量和每个元素的大小，在堆区分配一块连续的内存空间，并返回指向该空间的指针。如果分配成功，返回非空指针；如果分配失败，返回NULL。参数：calloc()函数的参数是需要分配的元素数量和每个元素的大小，单位分别是字节和元素个数。返回值：返回一个指向所分配内存的指针，如果分配失败则返回NULL。
动态数组
链表
在处理字符串时，我们经常需要将多个字符串连接在一起。为了实现这一点，通常需要动态分配足够的内存来存储连接后的字符串。
字符串连接
将一个字符串分割成多个部分时，可能需要为分割后的子字符串分配内存。
字符串分割
游戏对象管理
在游戏开发中，可能会创建大量的游戏对象（如角色、物品、敌人等）。为了有效地管理这些对象，通常需要在运行时动态分配内存。
栈内存分配
通过预先分配一块较大的内存区域，并按照需求将其划分为多个小块进行动态分配和回收，以提高内存分配和释放的效率。
动态内存池
BIG DATA EMPOWERS TO CREATE A NEWERA
动态内存分配函数
总结词：动态内存分配函数详细描述：malloc()函数用于在运行时动态分配内存。它根据所需的内存大小，在堆区分配一块连续的内存空间，并返回指向该空间的指针。如果分配成功，返回非空指针；如果分配失败，返回NULL。参数：malloc()函数的参数是需要分配的内存大小，单位是字节。返回值：返回一个指向所分配内存的指针，如果分配失败则返回NULL。
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

7.1.3 浅复制与深复制
探讨：
最后进一步讨论类的封装。封装的更高境界 是在该类对象中一切都是完备的、自给自足的，不 仅有数据和对数据的操作，还包括资源的动态安排 和释放。在需要时可以无条件地安全使用。标准 string类模板就是典型的例子。这样的类对象，作 为另一个类的成员对象使用时，就不会出任何问题。 这表明聚合实现了完善的封装。
注意cp等效于三维数组名，但没有指出其边界，即 最高维的元素数量，就像指向字符的指针即等效一 个字符串,不要把指向字符的指针，说成指向字符串 的指针。这与数组的嵌套定义相一致。
7.1.1自由存储区内存的分配与释放（选读）
比较：
float(*cp) [30] [20]; //三级指针 float (*bp) [20]; //二级指针 cp=new float [1] [30] [20]; bp=new float [30] [20]; 两个数组都是由600个浮点数组成，前者是只有一个元素 的三维数组，每个元素为30行20列的二维数组，而另一 个是有30个元素的二维数组，每个元素为20个元素的一 维数组。 删除这两个动态数组可用下式： delete [] cp; //删除（释放）三维数组 delete [] bp; //删除（释放）二维数组
7.1.1自由存储区内存的分配与释放
无名对象：
一般定义变量和对象时要用标识符命名，称命名对象，而动 态的称无名对象(请注意与栈区中的临时对象的区别，两者完 全不同：生命期不同，操作方法不同，临时变量对程序员是 透明的)。自由存储区是不会自动在分配时做初始化的（包括 清零），所以必须用初始化式(initializer)来显式初始化。
7.1.3
浅复制与深复制复制
当浅复制析构时，如用默认的析构 函数，则动态分配的自由存储区对象不 能回收。如果在析构函数中有“delete p;”语句，则如果先析构函数obj1时， 自由存储区对象已经释放，以后再析构 obj2时出现了二次释放的问题。 深复制：重新定义复制的构造函数， 给每个对象独立分配一个自由存储区 对象，称深复制。这时先复制对象主 体，再为obj2分配一个自由存储区对 象，最后用obj1的自由存储区对象复 制obj2的自由存储区对象。
P 自由存 储区对 象 复制前 P 自由存 储区对 象
obj1
obj1
P
复制后
图7.1 浅复制
obj2
如果类中有一个数据成员为指针，该类的一个对象obj1中 的这个指针p，指向了动态分配的一个自由存储区对象，（参见 图7.1复制前），如果用obj1按成员复制了一个对象obj2，这时 obj2.p也指向同一个自由存储区对象。
new表达式的操作：
从自由存储区分配对象，然后用括号中的值初始化该对象。 分配对象时，new表达式调用库操作符new()： int *pi=new int(0); pi现在所指向的变量的存储空间是由库操作符new()分配的， 位于程序的自由存储区中，并且该对象未命名。
7.1.1自由存储区内存的分配与释放
7.1.1自由存储区内存的分配与释放
数组动态分配格式：
指针变量名=new 类型名[下标表达式]; Delete[ ] 指向该数组的指针变量名;
说明：
两式中的方括号必须配对使用。 如果delete语句中少了方括号，因编译器认为该指针是指 向数组第一个元素的指针，会产生回收不彻底的问题（只 回收了第一个元素所占空间），加了方括号后就转化为指 向数组的指针，回收整个数组。 delete [ ]的方括号中不需要填数组元素数，系统自知。 即使写了，编译器也忽略。 请注意“下标表达式”不是常量表达式，即它的值不必 在编译时确定，可以在运行时确定。
演示：
１．用初始化式(initializer)来显式初始化
int *pi=new int(0); ２．当pi生命周期结束时， 必须释放pi所指向的目标： delete pi;
Ｐi
自由存储区
０
注意这时释放了pi所指的目标的内存空间，也就是撤销了 该目标，称动态内存释放（dynamic memory deallocation），但指针pi本身并没有撤销，该指针所占 内存空间并未释放。
【例7.2】 动态创建和删除一个m*n个元素的数组
7.1.1自由存储区的分配与释放
指针使用的要点：
1. 动态分配失败。返回一个空指针（NULL），表示发生了异 常，堆资源不足，分配失败。
2. 指针删除与自由存储区空间释放。删除一个指针p（delete p;）实际意思是删除了p所指的目标（变量或对象等）， 释放了它所占的自由存储区空间，而不是删除ｐ本身，释 放自由存储区空间后，ｐ成了空悬指针。空悬指针是程序 错误的一个根源）。建议这时将ｐ置空（NULL）。 3. new()和delete()是可以重载的，它们都是类的静态 成员函数。程序员无需显式声明它为静态的，系统自动 定义为静态的。本教材不讨论new()和delete()的重载。 未重载时，调用全局库操作符new()。
第七章 动态内存分配与数据结构
7.1自由存储区内存分配
7.2 链表与链表的基本操作
7.3 栈与队列的基本操作及其应用
7.4二叉树 （选读）
7.1自由存储区内存分配
静态存储分配：
通常定义变量(或对象)，编译器 在编译时都可以根据该变量(或 对象)的类型知道所需内存空间 的大小，从而系统在适当的时候 为它们分配确定的存储空间。
自由存储区对象的生命期并不依赖于建立它的作用域，所以 除非程序结束，自由存储区对象（无名对象）的生命期不会
到期，并且需要显式地用delete语句析构该类对象，上例执 行delete语句时，C++自动调用商品类的析构函数。
7.1.2自由存储区对象与构造函数
类对象初始化：
new后面类（class）类型可以有参数。这些参数即构造函数的 参数。但对创建数组，则无参数，只能调用默认的构造函数。
7.1.3 浅复制与深复制
思考：
深入地考虑【例7.4】，如果数据域还有很多其他数 据，甚至有好几个是动态建立的C字符串，深复制是不是太 复杂了？如果使用C++标准字符串string作为成员对象（聚 合）是否就不需要考虑深复制了？ 的确是这样的，准确地说，string类的内部包含动态建立字 符数组的操作，其复制构造函数是深复制。如果在student 类中使用string类而不是C字符串，就不要再考虑深复制问 题了。也就是说，动态内存分配和深复制应该放在一个适当 的层面上，一个更单纯的类定义中，如string类。在使用中， 把它作为一个成员对象，就像使用string类对象那样。
【例7.3】演示自由存储区对象分配和释放。
由自由存储区创建对象数组，只能调用默认 的构造函数，不能调用其他任何构造函数。如果 没有默认的构造函数，则不能创建对象数组。
7.1.3 浅复制与深复制
浅复制：
默认复制构造函数，可用一个类对象 初始化另一个类对象，称为默认的按成员复制，而不是 对整个类对象的按位复制。这称为浅复制。

自 由 存 储 区 对 象
obj1
P 自 由 存 储 区 对 象
obj2
图7.2 深复制
7.1.3 浅复制与深复制
【例7.4】定义复制构造函数 （copy structor）和复制赋值操 作符（copy Assignment Operator）实现深复制。
学生类定义： class student{ char *pName; //为了演示深复制，不用string类 public: student(); //默认构造函数 student(char *pname); //带参数构造函数 student(student &s); //复制构造函数 ~student(); //析构函数 student & operator=(student &s); }; //复制赋值操作符
7.1.2自由存储区对象与构造函数
类对象动态建立与删除过程：
通过new建立的对象要调用构造函数，通过delete删除对象 也要调用析构函数。 CGoods *pc; pc=new CGoods; //分配自由存储区空间，并构造一个无名的CGoods对象； ……. delete pc; //先析构，然后将内存空间返回给自由存储区；
7.1.1自由存储区内存的分配与释放
动态分配数组的特点：
1. 变量n在编译时没有确定的值，而是在运行中输入，按运行 时所需分配空间，这一点是动态分配的优点，可克服数组 “大开小用”的弊端，在表、排序与查找中的算法，若用 动态数组，通用性更佳。delete [ ]pc是将n个字符的空间 释放，而用delete pc则只释放了一个字符的空间； 2. 如果有char *pc1，令pc1=pc，同样可用delete [ ] pc1 来释放该空间。尽管C++不对数组作边界检查，但在自由 存储区 空间分配时，对数组分配空间大小是纪录在案的。 3. 没有初始化式（initializer），不可对数组初始化。
7.1.1自由存储区内存的分配与释放
4．内存泄漏（memory leak）和重复释放。new与 delete 是配对使用的， delete只能释放自由存储区空间。 如果new返回的指针值丢失，则所分配的自由存储区空间 无法回收，称内存泄漏，同一空间重复释放也是危险的， 因为该空间可能已另分配，所以必须妥善保存new返回的 指针，以保证不发生内存泄漏，也必须保证不会重复释放 自由存储区内存空间。 5．动态分配的变量或对象的生命期。无名对象的生命期 并不依赖于建立它的作用域，比如在函数中建立的动态对 象在函数返回后仍可使用。但必须记住释放该对象所占自 由存储区空间，并只能释放一次，在函数内建立，而在函 数外释放是一件很容易失控的事，往往会出错。
7.1.1自由存储区内存的分配与释放
【例7.1】动态数组的建立与撤销