经典C学习经验分享.ppt

《经典C学习经验分享.ppt》由会员分享，可在线阅读，更多相关《经典C学习经验分享.ppt（80页珍藏版）》请在三一文库上搜索。

1、C+面向对象程序设计 第三章 再论类和对象,第一章 C+的初步知识 第二章 类和对象 第三章 再论类和对象 第四章 运算符重载 第五章 继承与派生 第六章 多态性与虚函数 第七章 输入输出流 第八章 C+工具,3.1 构造函数 3.2 析构函数 3.3 调用构造函数和析构函数的顺序 3.4 对象数组 3.5 对象指针 3.6 共用数据的保护 3.7 对象的动态建立和释放 3.8 对象的赋值和复制 3.9 静态成员 3.10 友元 3.11 类模板,3.1 构造函数,对象的初始化 和普通变量一样，我们定义一个变量，往往同时进行初始化： int a = 3; 而声明类时，数据成员不能进行初始化：

2、class time int hour = 0; int minute = 0; int second = 0; 因为类不是实体，不占分配存储空间，显然无法容纳数据。,3.1 构造函数,如果一个类的所有数据成员都是公用的，我们可以象结构体变量那样，在定义对象时（而不是声明类时）进行初始化： class time public: int hour ; int minute; int second; ; time t1 = 13,30,20; 但在类的声明中，数据成员往往都是私有的，不能这样初始化。就需要一个公有成员函数来完成，而且应该是自动调用地完成。这就是构造函数。,3.1 构造函数,构造函数

3、的作用 C+提供了构造函数( constructor )来处理对象的初始化。构造函数是一个由用户定义的特殊的成员函数。与其他成员函数不同之处在于： 用户不能调用它，而是在定义对象时，有系统自动调用构造函数。 构造函数的名字必须与类名一致，不能是其他名字。 构造函数不能有任何返回类型。 用户如果没有定义构造函数，系统会自动生成一个构造函数，只不过函数体中没有任何语句。,3.1 构造函数,例3.1 将前例的时间类定义构造函数。在构造函数中加入输出语句，看看运行效果。,class time private: int hour, minute, second; public: time ( ) /ti

4、me 类的构造函数 hour = 0; minute = 0; second = 0; void setTime ( ); void showTime ( ) cout hour “:“ minute “:“ second endl; ;,void time:setTime ( ) couthour; coutminute; coutsecond; void main ( ) time t1; / 定义time类对象t1,调用构造函数tume ( ) t1.setTime( ); t1.showTime ( ); time t2; / 定义time类对象t2,调用构造函数tume ( ) t2

5、.setTime ( ); t2.showTime ( ); ,3.1 构造函数,带参数的构造函数 前一个示例中，每产生一个time了的对象，其初值都初始化为0。如果用户初始化时，不想将对象初值置为0而是其它值，就需要用带参数的构造函数来实现。 声明一个构造函数的一般格式为： 构造函数名 ( 类型1 形参1，类型2 形参2，)； 定义一个对象的一般格式为： 类名 对象名 ( 实参1，实参2， ）； 下面举例说明用法。,3.1 构造函数,例3.2 ：有两个长方体，长宽高分别为(1,2,3)和(4,5,6)。试编写一基于对象的程序，分别求他们的体积，并且要求用带参数的构造函数初始化他们。,#inc

6、lude class box private: int height, width, length; public: box ( int h, int w, int len ) height = h; width = w; length = len; int volume ( ) return height * width * length; ;,void main ( ) box box1 (1,2,3); cout “box1的体积为“ box1.volume( ) endl; box box2 (4,5,6); cout “box2的体积为“ box2.volume( ) endl; ,

7、3.1 构造函数,用参数初始化表对数据成员初始化 C+提供另一种初始化数据成员的方法：参数初始化表来实现对数据成员的初始化。这种方法不在函数体内初始化数据成员，而是在函数首部实现。例3.2 我们改写成如下形式：,#include class box private: int height, width, length; public: box(int h,int w,int len):height(h),width(w),length(len) int volume ( ) return height * width * length; ; void main ( ) box box1 (1,

8、2,3); cout “box1的体积为“ box1.volume( ) endl; box box2 (4,5,6); cout “box2的体积为“box2.volume( ) endl; ,3.1 构造函数,示例中的初始化表表示，用形参h的值初始化数据成员height，用w值初始化width，用len值初始化 length。这种初始化方法比较简练，可以直接在类体中定义构造函数。,3.1 构造函数,构造函数的重载 一个类中，可以有多个构造函数，只要他们的参数表不同。以方便同类对象不同初始化的需要。见下例3.3 ：,#include class circle private: float r

9、adius; public: circle( ); / 声明一个无参数构造函数 circle( float r ): radius (r) / 声明一个带参数构造函数 float area ( ) return radius * radius * 3.14159; ; circle:circle ( ) radius=10.0; void main ( ) circle c1 ( 1.0 ), c2; cout “c1的面积为“ c1.area( ) endl; cout “c2的面积为“ c2.area( ) endl; ,3.1 构造函数,说明 参数表为空的构造函数叫默认构造函数，一个类中

10、只能有一个默认函数。 定义对象时，如果想用默认构造函数初始化它，正确的定义形式为： circle c2; 而不是： circle c2 ( ); 一个类尽管定义了多个构造函数，一个对象只能用其中一个来初始化。,3.1 构造函数,使用默认参数的构造函数 构造函数的参数既可以通过实参传送，也可以指定为某些默认值。当用户不指定实参值时，编译系统便将默认值为形参值。 在实际生活中，常有一些这样的默认值。如计数器的默认值为0；战士的性别默认值为“男“；男性职工退休年龄默认值为60岁等，如果实际情况不是默认值，则由用户另外指定。采用默认值，可以减少用户的输入量。 下面举例说明。,3.1 构造函数,例3.4

11、 试将例3.3 的构造函数改用默认值的参数，半径值默认为1.0。,#include class circle private: float radius; public: circle( float r = 1.0 ); / 声明构造函数是指定默认参数 float area ( ) return radius * radius * 3.14159; ; circle:circle ( float r ) /定义函数时，可不再指定默认参数 radius = r; void main ( ) circle c1 (10.0), c2; cout “c1的面积为“ c1.area( ) endl;

12、cout “c2的面积为“ c2.area( ) endl; ,3.1 构造函数,构造函数中使用默认参数的好处 提供建立对象时的多种选择，相当于好几个重载的构造函数。 即使在调用构造时不提供参数也不会出错，因为有默认参数值参与对象初始化。 当每一个对象都是相同的初始值时，非常方便，用户不需要输入数据。,3.1 构造函数,默认参数值的构造函数使用注意 何处指定默认参数值？构造函数的声明处还是定义处？应该在构造函数的声明处指定默认参数值。因为类的声明在头文件中，用户是看得见的，而防在函数的定义处，用户不一定看得见。 一个类定义了全部是默认参数的构造函数后，不能再定义重载的构造函数。否则会产生多义性

13、，系统不知道调用哪一个。例如一个类有右边形式 的三个重载构造函数，若定义了如 下对象： circle circle1; 它调用哪一个构造函数呢？系统不 能确定，从而引起混乱。,circle ( float r=2.3 ); circle ( ); circle ( float );,3.2 析构函数,什么是析构函数？ 析构函数( destructor ) 也是一个特殊函数，它的作用与构造函数相反，是在撤消对象占用的内存前进行一些清理工作。它还可以被用来执行“用户希望在最后依次使用对象之后所执行的任何操作“。 析构函数的名称是类名的前面加一个取反符号“。我们在类的声明中定义析构函数。如果用户不定

14、义析构函数，系统便自动生成一个空的析构函数。 析构函数特点： 没有返回类型； 没有函数参数； 不能被重载。,3.2 析构函数,什么时候运行析构函数？ 当对象的生命结束时，会自动执行它的析构函数。具体而言，当出现以下几种情况，析构函数就会被执行。 如果在函数中定义了一个对象，当函数调用结束时，释放对象，释放对象前自动执行析构函数。 static 局部对象在函数调用结束时，包含的对象不会被释放，只在main函数结束或调用exit函数时，才调用static局部对象的析构函数。 如果定义了一个全局对象，则在程序的流程离开其作用域时（如main函数结束，或exit语句），调用该全局对象的析构函数。 如果

15、用new运算符动态地建立了一个对象，当用delete 运算符释放对象时，先调用该全局对象的析构函数。,3.2 析构函数,#include class box private: int height, width, length; public: box ( int h, int w, int len ) height = h; width = w; length = len; box ( ) / 析构函数 cout “Destructoring a object“ endl; int volume ( ) return height * width * length; ;,void main

16、( ) box box1 (1,2,3); cout “box1的体积为“ box1.volume( ) endl; box box2 (4,5,6); cout “box2的体积为“ box2.volume( ) endl; ,例3.5 析构函数举例。,3.3 调用构造函数和析构函数的顺序,调用构造函数和析构函数的顺序 先构造的后析构，后构造的先析构。,例: C3-5-1.CPP,3.3 调用构造函数和析构函数的顺序,注意:先构造的后析构，后构造的先析构,并非绝对成立! 对象不同的作用域,不同的存储类别,那么调用构造函数和析构函数的时候也有所不同. 例如: 一个程序中有多个文件,在多个文件中

17、定义了全局对象,那么这些对象的执行顺序是不确定的 在函数中定义局部自动对象,如果函数被多次调用 如果函数中定义静态局部对象,那么函数调用结束时对象并不释放,只有main结束或调用exit中才调用析构函数. Void fn() Student s1; static Student s2; 例: C3-5-2.CPP,3.4 对象数组,数组不仅可以由简单变量组成，也可以由对象组成，即每一个数组元素都是同类的对象。 例如，一个班有30人，每个学生的属性包括学号、姓名、性别。我们建立起学生类后，为每个学生建立一个对象，需要分别取30个对象名，很不方便。较好的做法是，定义一个“学生类“，的对象数组，每一

18、个数组元素是一个“学生类“的对象。 例如: Student stud30;,3.4 对象数组,在建立对象数组时，同样调用构造函数。 如果构造函数只有一个参数，在定义数组时可以在等号后面花括号内提供实参。 Student stud3=60，70，80； 实参个数不能超过数组元素个数，因为编译系统只为每个对象元素的构造函数传递一个实参 Student stud3=60，70，80，90；/不合法 如果构造函数有多个参数，则不能用在定义数组时直接提供所有实参的方法。 例如： Student:Student(int=1001,int=18,int=60)/构造函数 Student stud3=111，

19、34，31； 这种使用方式关系不清晰，出现歧义性,3.4 对象数组,构造函数有多个参数时,如下实现对数组对象的初始化. Student Stud3=Student(11,32,74), Student(12,34,27), Student(14,45,63) ; 如下面的例子.,3.4 对象数组,例:3.6-1.cpp,#include #include using namespace std; class student private: int num; string name; char sex; public: student( int n, string nam, char s )

20、num = n; name=nam; sex = s; cout “Constructor called.“ endl; student ( ) cout “Destructor called.“ endl; void display ( ); ;,void student:display ( ) cout“num:“numendl; cout“name:“nameendl; cout“sex:“; if (sex=0) cout“男“endl; else cout“女“endl; void main( ) student stud3 = student(1001,“张三“,1), stude

21、nt(1002,“李四“,0), student(1003,“王五“,0) ;/用指定参数的构造函数初始化数组 cout “第一个学生“ ; stud0.display( ); cout “第二个学生“ ; stud1.display( ); cout “第三个学生“ ; stud2.display( ); ,3.4 对象数组,例:C3-6.CPP,#include using namespace std; class Box public: Box(int h=10,int w=12,int len=15):height(h),width(w),length(len) int volume(

22、); private: int height; int width; int length; ;,int Box:volume() return(height*width*length); int main() Box a3= Box(10,12,15), Box(15,18,20), Box(16,20,26) ; cout“volume of a0 is “a0.volume()endl; cout“volume of a0 is “a1.volume()endl; cout“volume of a0 is “a2.volume()endl; return 0; ,3.5 对象指针,指向对

23、象的指针 创建一个类的对象时，系统会为每一个对象分配一定的存储空间，以存放成员。对象空间的起始地址就是对象的指针。可以定义一个指针，用来存放对象的指针. 格式: 类名 *对象指针名;,3.5 对象指针,指向对象的指针 例:c3-point.cpp 访问成员的方法：( *pt ).hour, (*pt).put ( ) 或者：pt-hour, pt-put( ),class Time public: int hour, minute, sec; void put ( ) hour = 12; minute = 0; sec = 0; ;,void main ( ) Time *pt, t1; p

24、t = ,3.5 对象指针,指向对象数据成员的指针 定义一个指向对象数据成员的指针变量的方法和前面介绍的定义指向普通变量的指针变量方法相同。 定义格式：数据类型名 * 指针变量名； 例如： int *pl; / 定义指向整形数据的指针变量 pl= / 输出t1.hour的值,3.5 对象指针,指向对象成员函数的指针 定义指向对象成员函数的指针变量的方法和定义指向普通函数的指针变量的方法有所不同。 指向普通函数的指针变量的定义方法： 返回数据类型 (*指针变量名) (参数表列)； 例：void (*p) ( ); / p是指向void 类型函数的指针变量 p = fun; / 将fun函数的入口

25、地址赋给指针变量p (*p)( ); / 调用fun函数 而定义一个指向对象成员函数的指针变量则不能这样： p = t1.put; / 出现编译错误，不知道t1.put所属的类,3.5 对象指针,定义指向公用成员函数的指针变量方法： 返回数据类型 ( 类名: *指针变量名) (参数表列)； 例：void (Time:*p2)( ); / Time:*p2的括号必须加上 令指针变量指向一个公用成员函数的方法： 指针变量名 = ,3.5 对象指针,#include using namespace std; class Time public: int hour, minute, sec; Time

26、 ( int h, int m, int s ) hour = h; minute = m; sec = s; void get_Time( ) cout hour“:“ minute“:“ secendl; ;,int main ( ) Time t1( 10,13,56 ); int *pl = ,3.5 对象指针,this 指针 通过第二章的学习我们知道，多个同类对象在内存中是共享成员函数的，以节省内存空间。那么，不同对象的成员函数引用数据成员时，怎么找到自己的数据成员呢？ C+在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，成为“this“。它是指向本对象的指针，它的值

27、是当前被调用的成员函数所在对象的起始地址。 例如，当a的成员函数调用数据成员a.volume时，编译系统就把对象a的起始地址赋给 this 指针，于是在成员函数引用数据成员时，就按照 this 的指向找到对象a 的数据成员。,3.5 对象指针,比如下列涉及数据成员的运算的返回语句： return length*width*height ; 实际上C+处理为： return ( this -length)*(this-width)*(this-height); 也可以写成如下形式： return (*this).length*(*this).width*(*this).height); 但不能写

28、成： return (*this.length) *(*this.width)*(*this.height); /错误 因为“.“操作符的优先级高于指针运算符“*“，(*this.length)就相当于*(this.length)，而 this.length 是不合法的，编译出错（应该是this-length）。,3.6 共用数据的保护,C+采用了不少的数据保护措施。最常用的，是将数据成员设置成私有数据( private )，以增加数据的安全性和私密性。 但是，有时候要求数据在能共享的前提下不能被篡改，我们就需要借助其他手段了。 什么手段呢？可以采用const，即把要保护的数据定义为常量。,3

29、.6 共用数据的保护,常对象 在定义对象时指定对象为常对象。常对象中的数据成员为常变量，并且必须要有初值： Time const t1(12,34,56); 这样，在所有的场合中，对象t1 的所有数据成员都被保护了，不能被修改。因此，凡是希望数据成员不能被改变的对象，可以声明为常对象。其声明格式为： 类名 const 对象名(参数表列)； 或者： const 类名 对象名(参数表列)； 两者等价。,3.6 共用数据的保护,如果一个对象被定义成常对象，那么不能调用该对象的非const 型成员函数，当然，系统隐含调用的构造函数和析构函数除外。比如： Time const t1( 12,34,56)

30、; / 定义t1为常对象 t1.get_Time( ); / 错误，get_Tiem( )不是const 型,不能调用 为什么会这样？因为成员函数有可能修改数据成员，而成员函数的定义可能和成员函数的声明不在同一文件，系统没法检测。所以，系统只能统一拦截，不让用户调用常对象的成员函数，除非该成员函数被声明成 const 类型。,3.6 共用数据的保护,怎样才能引用常对象的成员函数呢？很简单，只需要把该成员函数的声明为 const 类型，即常成员函数就行了。方法为： 函数返回类型 函数名(参数表列) const; 比如：void get_Time( ) const; / 将函数声明成const 类

31、型 常成员函数可以访问常对象中的数据成员，但仍然不准修改它们。 有时候编程要求必须修改某个常对象中的数据成员，如某个计数器count ，ANSI C+对此做了特殊的处理，将该数据成员 声明为 mutable，如： mutable int count; 这样，常对象的数据成员count，就可以用常成员函数来访问和修改了。,3.6 共用数据的保护,常对象成员 常数据成员：其作用和用法与一般常变量相似，在类的声明中，用关键词 const 来声明常数据成员，例如： const int hour; 注意：常数据成员的初始化，不能采用在构造函数中对常数据成员赋予初值的方法，只能通过构造函数的参数初始化表对

32、常数据成员进行初始化。 在类外定义构造函数，初始化形式为： Time:Time ( int h ): hour ( h ) 在类中声明了某一个数据成员为常数据成员后，该类的所有对象中的该数据成员的值是不可改变的，但可以是不同的（由每个对象的参数初始化表决定）。,3.6 共用数据的保护,常成员函数 一般的成员函数可以引用本对象中的非const 数据成员，也可以修改它们。但如果成员函数声明为常成员函数，则只能引用本对象中的数据成员，而不能修改它们。如 void get_Time( ) const; / const位置在最后 const 是函数类型的一部分，在声明函数和定义函数时都要用到 const

33、 关键字。 常成员函数可以引用常数据成员，也可以引用非const数据成员；而常数据成员可以被常成员函数引用，也可以被非 const 成员函数引用。见90页表总结。,3.6 共用数据的保护,3.6 共用数据的保护,怎样使用常成员函数呢？ 类中如果一些数据成员需要保护，另一些数据成员不需保护，我们就将需要保护的数据成员声明为 const ，以保证其值不被改变。 类中如果所有数据成员都需保护，可以将所有数据成员都声明成 const ，本对象的任何成员函数，都只能引用，不能改变它们。或者将这些数据成员所属的对象声明成const，只让本对象的const 成员函数可引用，但不能改变。 如果一个对象被定义成

34、了常对象，只能调用其中的const成员函数，不能调用非const成员函数。 常成员函数不能调用另一个非const成员函数,回忆:常对象,常数据成员,常成员函数,class Time public: Time(int=0,int=0,int=0); void call(); int hour; int min; int sec; ; Time:Time(int h,int m,int s) hour=h; min=m; sec=s; Time const t(2,3,4); /t为常对象,回忆:常对象,常数据成员,常成员函数,class Time public: void call() cons

35、t; ; void Time:call() const cout“Call:“hour“-“min“-“secendl; Time const t(2,3,4); t.call();,如果需要访问常对象中的成员函数，则需要将其声明为const。表示这是一个常成员函数，常成员函数可以访问常对象中的数据成员，但仍然不允许修改常对象中数据成员的值。,回忆:常对象,常数据成员,常成员函数,class Time public: void setHour(int) const; mutable int hour;/可以修改hour的值，通过setHour() int min; /不可以修改min的值，re

36、ad-only int sec; /不可以修改sec的值，read-only ; void Time:setHour(int h) const hour=h; Time const t(2,3,4); t.setHour(5);,如果需要修改常对象中某个数据成员的值，则可将该数据成员声明为mutable。,回忆:常对象,常数据成员,常成员函数,class Time public: Time(int,int,int); const int hour;/声明hour为常数据成员 int min; int sec; Time:Time(int h,int m,int s):hour(h) /通过参数

37、初始化表hour(h)对常数据成员hour初始化 min=m; sec=s; Time t(2,3,4);,用关键字const来声明常数据成员。在类体中声明了某一个常数据成员后，该类所有对象中的该数据成员的值都是不能改变的，但不同对象中该数据成员的值是可以不同的（在定义对象时给定）。只能通过构造函数的参数初始化表对常数据成员进行初始化。,3.6 共用数据的保护,指向对象的常指针 将指向对象的指针变量声明为const ，并将之初始化，可以使指针值恒定为初始值，即其指向始终不变。如 Time t1(10,12,14), t2; /定义对象 Time * const ptr = / 错误，常指针不能

38、改变指向 定义一个指向对象的常指针的格式为： 类名 * const 指针变量名 = 对象地址； 指向对象的常指针，这个变量的值是一个对象的地址，他不允许被改变，但所指对象的内容可以改变。 什么时候需要常指针让其指向对象？如果想将一个指针变量与一个对象固定地联系在一起，以防止误操作；往往用常指针作为函数的形参，目的是不允许在函数执行过程中改变指针值，使其始终指向原来的对象。,3.6 共用数据的保护,Time t(2,3,4); Time *const p; /error:uninitialized const p p=,Time t(2,3,4); Time *const p=,/error:a

39、ssignment of read-only variable p,指向对象的常指针,3.6 共用数据的保护,class Time public: void call(); int hour; private: int min; void Time:call() coutcall(); p-hour=0; p-min=0; p-call(); ,指向对象的常指针:找出下面的错误!,error:int Time:min is private,3.6 共用数据的保护,指向常对象的指针 定义指向常对象的指针格式： const 类名 * 指针名； 这和C语言中指向常变量的指针是一样的。只需将上述格式中

40、的类名换成类型名就行了。我们不妨在一起作如下讨论： 如果一个变量被声明为常对象（/ 常变量），只能用指向常对象（/ 常变量）的指针指向它。如： const char c = “boy“; / 定义const型的常字符数组 const char * p1; / p1为指向常字符变量的指针 p1 = c; / 合法，p1指向常变量 char * p2 = c / 非法，p2不是指向常变量的指针 指向常变量的指针如果指向了非const对象，其指向的对象值不能用指针改变，可以用非指针方式改变。 Time t1(10,12,14); / 定义Time类对象t1，它不是常对象 const Time *p

41、= / 非法，不能通过指针改变t1的值,3.6 共用数据的保护,用指针变量作形参时，形参和实参的对应关系见下表,3.6 共用数据的保护,例如： const char str = “boy“; / str是常数组名 void func(char * ptr); / 函数形参为指向非const变量的指针 func (str); / 非法，实参是常变量指针，形参是非const变量指针 出错原因： 形参是非指向非const型变量的指针，在函数中可以也可能改变指针所指变量值，而实参是指向常变量的指针，不能被改变，发生矛盾。,3.6 共用数据的保护,指向常对象的指针最常用于函数的形参，目的是保护形参指针所

42、指的对象，使它在函数执行过程中不被修改。如 void func( const Time * P) /形参是指向常对象的指针变量 p-hour = 18; / 错误，指向的常对象被修改了 couthourendl; void main( ) Time t1(10,12,14); func( 如果func形参不是指向const 型的Time对象的指针，即没有const限定词，则t1的hour就可以被修改。,3.6 共用数据的保护,有人可能会问，我不将func函数的形参定义为const型对象，只将 t1 定义为const 型对象，不是也能保护 t1 在func中不被篡改吗？ 不行，会出现编译错误。因

43、为指向非const 对象的指针不能指向const 对象；同理，指向非const 变量的指针不能指向const 变量。 不能通过指向常对象的指针改变所指对象的值，但指针变量本身的值可以改变。,3.6 共用数据的保护,何时使用指向常对象的指针？何时使用常对象？ 当希望在调用函数时对象的值不能被修改，就应该把形参定义为指向常对象的指针，同时用对象的地址做实参，而实参对象可以是const型，也可以是非 const型。 如果要求对象不仅在函数调用过程中不被修改，而且在整个程序运行时不被修改，就应该把该对象定义成常对象。,3.6 共用数据的保护,对象的常引用 前面讲过，引用主要是用于函数调用，将改变后的变

44、量值带回到被调用的函数外。 但如果不希望在函数中修改参数，可以把引用型形参定义成 const 型： 函数返回类型 函数名( const 形参类型 则在函数中不能改变形参值，也就不能改变对应的实参值。 (例3-8) 什么时候使用常指针和常引用？使用常指针或常引用作为函数参数，既能保证数据安全，不被修改；调用函数时又能不必建立实参的拷贝，提高了程序运行效率，节省了内存空间。,3.6 共用数据的保护,const 数据小结,3.7 对象的动态建立和释放,问题的提出：前面我们所学创建对象的方法都是静态的，它们在程序 运行过程中所占用的内存空间不能被释放。比如，在一个函数中定义了一个对象，只有在函数结束时

45、，该对象才能被释放。 有时候，人们希望对象的创建和释放是在程序运行时，由运行程序的人决定，比如，链表结构的建立和删除，这就需要动态建立和释放对象。 C+语言用new、delete 这两个运算符来实现。内存的分配和释放，也用来实现对象的建立与撤消。,3.7 对象的动态建立和释放,动态建立对象的方法： 如果已经定义了一个 Box 类，可以用new 运算符动态地创建一个 Box 对象： new Box; 系统执行此语句时，首先开辟一段内存空间，并在此空间中存放一个 Box 类对象，同时运行该类的构造函数，以初始化该对象，然后返回一个指向该对象的指针值。 但此时用户还不能访问这个对象，因为它既没有对象

46、名，用户也不知道它的地址。这种对象称为“无名对象“。我们应该这样做： Box *pt; / 定义一个指向Box类对象的指针pt pt = new Box; / 创建一个Box对象，将新对象的指针值赋给pt cout height endl;,3.7 对象的动态建立和释放,用new 动态创建的对象一般没有对象名，只能通过指针访问。 在执行new 运算时，如果内存不足，则创建失败。大多数C+编译系统都让 new 返回一个0指针，表示内存不足，操作失败。 动态撤消对象的方法：由new 创建的对象不再需要时，可以由delete运算符释放。上例pt的释放方法为： delete pt； 这样就撤消了pt指

47、向的对象。 在执行 delete运算符时，在释放空间以前，系统自动调用析构函数，完成有关善后清理工作。,3.8 对象的赋值与复制,对象的赋值 如果一个类定义了两个或多个对象，则这些同类对象之间可以互相赋值 一般形式： 对象名对象名 赋值过程实际上是将一个对象的成员值一一复制给另一个对象的对应成员完成的 例 注意： 对象的赋值只对其中的数据成员赋值，而不对成员函数赋值 类的数据成员中不能包括动态分配的数据，否则可能出现严重后果,3.8 对象的赋值与复制,对象的复制 问题的提出：有时需要多个完全相同的对象，用前面介绍的办法进行处理，我们得定义多个同类对象，然后用相同的数据去构造初始化它们，比较费时

48、麻烦。可不可以用克隆的方法呢？ 可以。C+可以根据一个已知的对象快速地复制出多个完全相同的对象。比如： Box box2(box1); 其作用就是对象的克隆，即用一个已知的对象 box1复制出一个完全相同的新对象 box2。 对象复制的格式： 类名 被克隆出来的新对象名（已有的对象名）；,3.8 对象的赋值与复制,从上面的一般形式可以看出，复制对象是一种特殊的构造对象方法，其构造参数参数不是一般变量，而必须是一个对象！请看： / 复制构造函数 Box:Box ( const Box 复制构造函数也是构造函数，它只有一个参数，这个参数是本类已有对象，而且采用常引用形式，使参数不能被改变。复制构造函数的作用是将实参对象的各个数据成员值一一赋予给新的对象中对应的数据成员。,3.8 对象的赋值与复制,C+还使用另一种方便的对象复制形式，形式为： 类名 目标对象名