第6章类与对象的定义与访问

第6章类与对象P216

•类（Class）是面向对象程序设计（OOP）

实现信息封装的基础。

­类是用户定义类型，也称为类类型。

•每个类包含数据说明和一组操作数据或传

递消息的函数。

•类的实例称为对象。

6.1类和对象的定义与访问P216

•在面向对象程序设计中，类是程序基本单位。

­类是数据和操作数据的函数的封装。

•类的对象使用自己的方法完成对数据的操作。

­类可以隐藏数据和操作细节，对象通过类接口

与外部通信。

例1・2用面向对象方法编程,

求圆的周长和面积P4

圆类

数据成员

半径

成员函数

置半径值

求圆的半径

求周长

求面积

〃例1-2输入圆的半径，求圆的周长和面积(用面向对象方法编程)P4

#include<iostream>

usingnamespacestd;

classCircle

{private:

doubleradius;

public:

voidSet_Radius(doubler){radius=r;}

doubleGet_Radius(){returnradius;}

doubleGet_Girth(){return2*3.14f*radius;}

doubleGet_Area(){return3.14f*radius*radius;}

}；"

intmain()

{CircleA,B;

A.Set_Radius(6.23);

cout«"A.Radius=H«A.Get_Radius()«endl;

cout«"A.Girth="«A.Get_Girth()«endl;

cout«"A.Area="«A.Get_Area()«endl;

B.Set_Radius(10.5);

cout«"B.radius="«B.Get_Radius()«endl;

cout«"B.Girths'1«B.Get_Girth()«endl;

cout«"B.Area=11«B.Get_Area()«endl;

return(O);

}

例1一2用面向对象方法编程，求圆的周长和面积

#include<iostream>

数据成员

usingnamespacestd

classCircle

{doubleradius;

public:

voidSet_Radius(doubler){radius=r；}

doubleGet_Radius(){returnradius;}

doubleGet_Girth(){return2*3.14*radius;}

doubleGet_Area(){return3.14*radius*radius;}

}；

intmain()

{CircleA,B;

A.Set_Radius(6.23);

cout«"A.Radius="vvA.Get_Radius()«endl;

cout«"A.Girth="<vA.Get_Girth()«endl;

cout«"A.Area="«A.Get_Area()«endl;

B.Set_Radius(10.5);

cout«"B.radius="«B.Get_Radius()«endl;

cout«"B.Girth="«B.Get_Girth()«endl;

cout«"B.Area="«B.Get_Area()«endl;

例1一2用面向对象方法编程，求圆的周长和面积

#include<iostream>

usingnamespacestd;

classCircle成员函数

{doubleradius;

public:

voidSet_Radius(doubler){radius-r;}

doubleGet_Radius(){returnradius;}

doubleGet_Girth(){return2*3.14*radius;}

doubleGet_Area(){return3.14*radius*radius;}

}；

intmain()

{CircleA,B;

A.Set_Radius(6.23);

cout«"A.Radius="«A.Get_Radius()«endl;

cout«"A.Girth="<vA.Get_Girth()«endl;

cout«"A.Area="«A.Get_Area()«endl;

B.Set_Radius(10.5);

cout«nB.radius="«B.Get_Radius()«endl;

cout«”B.Girth="wB.Get_Girth()«endl;

cout«"B.Area="«B.Get_Area()«endl;

例1一2用面向对象方法编程，求圆的周长和面积

#include<iostream>

usingnamespacestd;

classCircle

{doubleradius;

public:

voidSet_Radius(doubler){radius=r；}

doubleGet_Radius(){returnradius;}

doubleGet_Girth(){retuip2*3.14*radius;,

doubleGet_Area()Ld^turi建立对象is;}

L；main()(类类型变量)

{CircleA,B;

A.Set_Radius(6.23);

cout«"A.Radius="«A.Get_Radius()«endl;

cout«"A.Girth="<vA.Get_Girth()«endl;

cout«"A.Area="«A.Get_Area()«endl;

B.Set_Radius(10.5);

cout«nB.radius="«B.Get_Radius()«endl;

cout«”B.Girth="wB.Get_Girth()«endl;

cout«"B.Area="«B.Get_Area()«endl;

例1一2用面向对象方法编程，求圆的周长和面积

#include<iostream>

usingnamespacestd;

classCircle

{doubleradius;

public:

voidSet_Radius(doubler){radius=r；}

doubleGet_Radius(){returnradius;}通过对象

doubleGet_Girth(){return2*3.14*qdi；｝调用类的成员函数

doubleGet_Area(){return3.14*radyls*radius-77

J,

intmain()

{CircleA,B;

A.Set_Radius(6.23);

cout«"A.Radius="«A.GetRadius()«endl;

cout«"A.Girth="«A.Get_Girth()«endl;

cout«"A.Area="v<A.Get_Area()«endl;

B.Set_Radius(10.5);

cout«"B.radius="«B.Get_Radius()«endl;

cout«"B.Girth="«B.Get_Girth()«endl;

cout«"B.Area="«B.Get_Area()«endl;

数组类型定义与排序操作P217

〃排序函数原型

voidSort(int[],int);

〃数组相加函数原型

voidAdd(int[],int[],int);

//

intmain()

{inta[10],b[10];

II.......

Sort(a,10);

Sort(b,10);

Add(a,b,10);

II.......

)

“数组类”类型P217

•设计一个“数组类”类型，把数组类型定

义和对数组排序操作封装在一起。

•这样“排序”就成了所有数组类对象自己

做的操作。

封装classArray〃定义数组类

{int*ap;intlen;

数组与数组类

public:

〃排序函数原型Array(intsize)〃建立数组

voidSort(int[],int);{len=size;ap=newint[size];}

〃数组相加函数原型voidSort();//排序

voidAdd(int[],int[],int);〃重载算符中函数

Arrayoperaor+(constArray&other);

intmain())；

{inta[10],b[10];

intmain()

{Arraya(10),b(10);〃声明对象

Sort(a,10);

Sort(b,10);a.Sort();b.Sort();〃调用排序方法

Add(a,b,10);a=a+b;〃数组相加

封装

classArray〃定义数组类

finf*ap;intlen;

die:

trray(intsize)〃建立数组

len=size;ap=newint[size];}

oidSort();〃排序

/重载算符+函数

rrayoperaor+(constArray&other);

111L

{inta[10],b[10];

intmainQ

{Arraya(10),b(10);〃声明对象

Sort(a,10);

Sort(b,10);a.Sort();b.Sort();〃调用排序方法

Add(a,b,10);a=a+b;〃数组相加

封装

classArray〃定义数组类

数组与数组类int*ap;intlen;

public:

//排序函数原型Array(intsize)〃建立数组

voidSort(int[],int);{len=size;ap=newint[size];}

〃数组相加函数原型voidSort();//排序

void战算符+函数

operaor+(constArray&other);

intm

{int

：)

a(10),b(10);〃声明对象

Son

Sona-Sort();b.Sort();//调用排序方法

Add(a,b,10);a=a+b;〃数组相加

6.1.1定义类与对象P218

•C++中，类定义的说明语句一般形式为:

class类名

{public:

公有性质数据成员和成员函数；

protected:

保护性质数据成员和成员函数；

private:

私有性质数据成员和成员函数；

};

说明P218

•其中，class是定义类的关键字。

■“类名”是用户自定义的标识符，用于标

识类型名字。通常第一个字母大写。

•一对花括号相括说明类成员，以分号结束

类定义语句。

*成员的性质

­类成员用关键字指定不同访问特性，决定其在类体系

中或类外的可见性。

•private声明私有成员：私有性质成员仅在类中可见。

不能在类外或派生类中使用。如果私有类成员放在放

在第一段，则可以省略关键字private。（建议不省）

•protected声明保护成员：保护性质成员在本类和它

的派生类中可见。

•public声明公有成员：公有性质的成员是的接口，在

类中和类外可见。

•各段中既可以包含数据成员，也可以包含成员函数。

成员函数可在类外定义P219

•成员函数在类外定义，使用作用域区分符

进行说明，此时函数头形式为：

返回类型类名：：函数名（参数表）

•简单的成员函数实现可以在类中定义，此

时编译器作内联函数处理。

关键字struct也可定义类P218

•除了关键字class外，关键字struct也可

定义类。

•用关键字struct也可定义类时，若不特别

指出，则所有成员都是公有成员。

关于类声明的进一步说明

1.允许已定义类名出现在类的说明中

允许已定义类名出现在类的说明中

例：

classX

）；

classY

{XdataMember;

）；

允许已定义类名出现在类的说明中

例:

classlink

{link*next;

//声明一个指向link类类型的指针

）；

2.类可以无名,用于直接声明对象

}mydate;

3.类是一个程序包

•可以只有数据成员或只有成员函数，或者为空

#include<iostream>

usingnamespacestd;

classempty{};

intmain()

{emptye1;

cout«M&e1="«&e1«endl;

cout«Msizeofe1=M«sizeof(el)«endl;

}

强调

注:

1.允许已定义类名出现在类的说明中

2.类可以无名，用于直接声明对象

3.类是一个程序包。可以只有数据成员或只有成员函数，或者为空。

//例

#include<iostream>

CAC:\WIND0WS\systefn32\(

usingnamespacestd;*1=0012FF63日

classempty{};sizeofe1=1

intmain()请按任意犍继续..

Lil

{emptyel;

cout«n&el="vv&el«endl;

cout«"sizeofel="«sizeofifel)«endl;

“类”类型变量的定义P219

・“类”类型变量的定义，定义方法与普通结

构类型变量定义方法相同。

•说明一个类类型的对象（变量）后，编译

器为每个对象的数据成员分配内存。

•对象没有成员函数的副本，类成员函数可

以被对象调用。

6.1.2访问对象成员P220

•公有成员是提供给外部的接口。

・类外用”.”和“•>”运算符访问对象成员。

访问对象的公有成员P220

〃例6」访问对象的公有成员P220

#include<iostream>

usingnamespacestd;

classTclass

{public:

intx,y;

voidprint()

{cout«xw"Jwy;};

)；

intmain()

{Tclasstest;

test.x=100;test.y=200;

test.print();

)

〃例6・2用指针访问对象成员

#include<iostream>

usingnamespacestd;

classTclass

{public:

intx,y;

voidprint(){cout«x««y«endl;};

)；

intadd(Tclass*ptf){return(ptf->x+ptf->y);}

intmain()

{Tclasstest,*pt=new(Tclass);

pt->x=100;pt->y=200;

pt->print();

test.x=150;test.y=450;

test.print();

cout«"x+y="«add(&test);

)

6.1.3this指针P221

・C++中，同一类的各个对象都有自己的数据成员

的存储空间，系统不为每个类的对象建立成员函

数副本，但类的成员函数可以被各个对象调用。

•C++为成员函数提供了一个称为this的隐含指针

参数，所以常常称成员函数拥有this指针。

•当一个对象调用类的成员函数时，对象的地址被

传递给this指针，即this指针指向了该对象。

•this指针不能显式声明，但可以显式使用。

说明

・this指针是一个常指针，相当于：

•class_Type*constthis;

•其中：

・class_Type是用户定义的类类型标识符。

■这里，this指针一旦初始化（成员函数被调用）

之后，获取了对象地址，指针值就不能再修改

和赋值，以保证不会指向其它对象。

•this指针的显式使用主要在运算符重载、自引

用等场合。

this指针

#include<iostream>

usingnamespacestd;

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b；}

voidprintXY(){cout«x«”,«y«endl;};

}；

intmain()

{Simpleobjl,obj2,obj3;

objl.setXY(10,15);obj1.xobjl.y

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>

usingnamespacestd;

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a:y=b；}

voidprintXY(){cout«x«”,«y«endl;};

}；

intmain()

{Simpleobjl,obj2,obj3;

objl.setXY(10,15);obj1.xobjl.y

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>向哪个对象

usingnamespacestd;的数据成员赋值?

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a:y=b;}

voidprintXY(){夕out<<x««y«endl;};

)；//

♦•八11

mtmam()//

{Simpleobj1,objQ,obj3；

objl.setXY(10,15，;

obj1.printXY();

obj2.setXY(20,25);

obj2.printXY();

obj3.setXY(30,35);

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

成员函数隐含定义this指针

usingnamespacestd;

classSimple接受调用对象的地址

{intx,y;

public:

voidsetXY(inta,intb){x=a;y

voidsetXY(inta,intb,Simple*con){this->x=a;this->y=b;}

intmain()

{Simpleobj1,obj2,，

objl.setXY(10,15Mobjn;

obj1.printXY();

obj2.setXY(20,25);

obj2.printXY();

obj3.setXY(30,35);

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

this指针不能显式声明

usingnamespacestd;

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y:

voidsetXY(inta,intb){this->x=a;this->y=b;}

J，

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15)；obj1.xobjl.y

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

this指针不能显式声明

usingnamespacestd;

classSimple可以显式使用

{intx,y;

public:

voidsetXY(inta,intb){x=a;y:

voidsetXY(inta,intb){this->x=a;this->y=b;}

J，

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.xobjl.y

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;

classSimple通过调用函数的对象

{intx,y;this指针获取对象地址

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXYQ4cout«x«vvy«endl;};

/

intmain()/

{Simnlgfobjl,obj2,obj3;

objl?>etXY(10,15);obj1.xobjl.y

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3,xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.xobj2.y

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacest^;在objl上操作10,15

classSimple

{intx,y;

public:

voidsetXX(inta,intb){x=a;y=b;}

voidprintXY(){cout«xvv"J«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);

Cggp.printXY^

obj2.setXY(20,25);

obj2.printXY();

obj3.setXY(30,35);

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.y

obj2.printXY();

obj3.setXY(30,35);obj3,xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespaces叱

在obj2上操作10,15

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);

obj1.printXY();

之亚.setXY(2U,军力;

obj2.printXY();

obj3.setXY(30,35);

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

町在上操作

usingnamespaces0bj?10,15

classSimple/_______________

{intx,y;/

public:J

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

COST.setXY(2025^obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacest^;在obj2上操作10,15

classSimple

{intx,y;

public:

voidsetXX(inta,intb){x=a;y=b;}

voidprintXY(){cout«xvv"J«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

•printXY^

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacest^;在obj2上操作10,15

classSimple20,25

{intx,y;

public:

voidsetXX(inta,intb){x=a;y=b;}

voidprintXY(){cout«xvv"J«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

•printXY^

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3,setXY(30,35);obj3.xobj3.y

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3,setXY(30,35);obj3.x30obj3.y35

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.x30obj3.y35

obj3.printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«xvv"J«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.x30obj3.y35

obj3,printXY();

6.1.3this指针

#include<iostream>〃例6-5

usingnamespacestd;10,15

classSimple20,25

{intx,y;30,35

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«xvv"J«y«endl;};

intmain()

{Simpleobj1,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.x30obj3.y35

obj3,printXY();

6.1.3this指针

#include<iostream'

.一J

usingnamespacesi15

成员函数拥有this指针

classSimple15

{intx,y;行

public:

voidsetXY(inta,intb){x=a;y=b;}

voidprintXY(){cout«x«n,n«y«endl;};

}；

intmain()

{Simpleobjl,obj2,obj3;

objl.setXY(10,15);obj1.x10objl.y15

obj1.printXY();

obj2.setXY(20,25);obj2.x20obj2.y25

obj2.printXY();

obj3.setXY(30,35);obj3.x30obj3.y35

obj3.printXY();

6.2构造函数和析构函数P222

基本概念

■在类中构造函数和析构函数都是特殊函数。

•构造函数用于建立类的实例；

•析构函数用于撤消类的实例。

■程序并不显式调用这些函数，当程序创建一个

对象时，系统自动调用构造函数；

•当程序撤消一个对象时，系统自动调用析构函

数。

•这些都是编译器自动调用的。

构造函数P222

•构造函数是用于创建对象的特殊成员函数。

•当创建对象时，系统自动调用构造函数。

•构造函数的作用是：

为对象分配空间；

对数据成员赋初值；

请求其他资源。

说明

・构造函数名与类名相同：类名

•构造函数可以有任意类型的参数，但没有返回

类型。

•构造函数可以由用户提供，也可使用系统的默

认版本。

•如果没有用户定义的构造函数时，系统提供缺

省版本的构造函数，只负责对象的创建，不能

为对象中的数据成员赋初值。（不做数据成员

初始化工作）

•构造函数可以重载。

何时调用构造函数

・何时调用构造函数十分明确：

•定义类的对象时；

•调用new或者new□运算符动态开辟内存空间时。

•在对象被创建的时候就会调用构造函数，

•比如：声明一个类classA{・.J,

•当你在main函数中Aa；

•定义一个对象a的时候，就调用构造函数。

•默认构造函数都是无参数的。

何时调用析构函数

•何时调用构造函数要十分明确：

•当函数调用结束的时候，会自动调用析构

函数，析构的作用就是释放对象占用的资

源。

・以为默认析构什么也不打印，所以你不会

直观看出析构函数什么时候执行，i己在

析构中加上打印的语言你就会看到了。

构造函数和析构函数

例:

classAA

{public:

AA(){……}

〜AA(){……}

};

voidtest()

{intx,y;

AAtl,t2;

return;

构造函数和析构函教_

构造函数

};

voidtest()

{intx,y;

AAtl,t2;

return;

构造函数和析构函数

例:/析构函数

classAA//

{public://

AA(){…./

)；

voidtest()

{intx,y;

AAtl,t2;

return;

构造函数和析构函数

例:

classAA

{public:

AA(){……}

〜AA(){.......

｝；

voidtest()

{intx,y;〃声明变量时开辟两个整型存储空间

AAtl,t2;

return;

构造函数和析构函数

例:

classAA

{public:

AA(){……}

〜AA(){.......

};

voidtest()

{intx,y;

〃两次调用构造函数,对象tl,t2

return;

构造函数和析构函数

例:

classAA

{public:

AX01

〜AA(){

｝；

voidtest()

{intx,y;

AAtl,t2;〃两次调用构造函数,创建对象

return;

构造函数和析构函数

例:

classAA

{public:

AA(){……}

〜AA(){.......

};

voidtest()

{intx,y;

AAtl,t2;

return;

〃两次调用析构函数,撤消对象tl,t2

构造函数和析构函数

例:

classAA

{public:

AA(){

〜AA(){……}

};

voidtest()

{intx,y;

AAtl,t2;

return;//两次调用析构函数,撤消对象

构造函数和析构函数

例:

classAA

{public:

AA(){……}

〜AA(){.......

};

voidtest()

{intx,y;

AAtl,t2;

return;〃两次调用析构函数,撤消对象

}

〃变量生存期结束

6.2.1简单构造函数和析构函数

P222

■构造函数原型

类名：：类名(参数表)、

•析构函数原型

类名~类名()

#include<iostream>//例6-3重写日期类P223

usingnamespacestd;

classDate

{public:

Date();

-Date();

voidSetDate(inty,intm,intd);

intIsLeapYear();

voidPrintDate();

private:

intyear,month,day;

}；

Date::Date(){cout«"DateobjectinitializedAn";}〃无参构造函数

Date::-Date(){cout«nDateobjectdestroyed.\n";}//析构函数

voidDate::SetDate(inty,intm,intd){year=y;month=m;day=d;}

intDate::IsLeapYear(){return(year%4==0&&year%100!=0)||(year%400==0);}

voidDate::PrintDate(){cout«year««month««day«endl;}

intmain()

{Dated;

d.SetDate(2001,10,1);

d.PrintDate();

}

#include<iostream>〃例6・3重写日期类P223

usingnamespacestd;

classDate

{public:

Date();

~Date();

voidSetDate(inty,intm,intd);

intIsLeapYear();

voidPrintDate();

private:

intyear,month,day;

}；

Date::Date(){coutvv"Dateobjectinitialized.、!!'';}〃无参构造函数

Date::~Date()"Dateobjectdestroyed.\n";}//析构函

voidDate::SetDate(intintd){year=y;monthday=d;}

intDate::IsLeapYear()

voidDate::PrintDate()

创建对象时

intmain()

调用构造函数

d.SetDate(2001,10,l);

d.PrintDate();

#include<iostream>〃例重写日期类P223

usingnamespacestd;

classDate

{public:

Date();

〜Date。;

voidSetDate(inty,intm,intd);

intIsLeapYear();

voidPrintDate();

private:

intyear,month,day;

｝；

Date::Date(){cout«"Dateobjectinitialized.、!!"；}//无参构造函数

Date::-Date(){cout«”Dateobjectdestroyed.\nn;}〃析构函数

voidDate::Setinty,intm,intd){year=y;month=m;day=d;}

intDate::IsLeapYear(){reear%4==0&&year%100!=0)||(year%400==0);}

voidDate::PrintDate(){cout«year<«ndl;}

intmain()作用域结束时

{Dated;调用析构函数

d.SetDate(2001,10,ll<

d.PrintDate();

)

#include<iostream>〃例6-3重写日期类P223

usingnamespacestd;

CAC：\VIID0TS\systeB32\cBd.exe

classDate

Dateobjectinitialized.

{public:2001/10/1

Date();Dateobjectdestroyed.

~Date();请按任意键继续.•.

voidSetDate(inty,intm,intd);

intIsLeapYear();