Chap3 类和对象800.docx

Chap3 类和对象800.docx

《Chap3 类和对象800.docx》由会员分享，可在线阅读，更多相关《Chap3 类和对象800.docx（16页珍藏版）》请在冰豆网上搜索。

Chap3类和对象800

用class来构造，声明class的语法同C中声明struct相似，但class还可包含函数声明。

Chap3类和对象

3.1C++类的构成

例：

classPoint{

intx,y;

public:

voidSetPoint（int,int）;

intGetX（）;

intGetY（）;

};

1．基本格式：

class类名{

private:

私有数据成员和成员函数

protected:

受保护数据成员和成员函数

public:

公有数据成员和成员函数

};

各成员函数的实现（定义部分）

①访问权限的说明顺序和次数是任意的

②当私有段成员处于类声明中的第一部分，private关键字可以省略

③数据成员的声明同普通变量的声明相同，其类型可以是任意的，但不能使用auto、extern、register修饰数据成员

④不能在类的声明部分初始化数据成员

//常范错误：

“；”漏掉啦！

2．类成员使用说明

●私有成员：

只有类本身的成员函数能够访问，任何类以外的函数对私有成员的访问都是非法的，如Point类中x,y

●公有成员：

提供了类的外部界面，允许类的使用者（对象）访问，即可以通过类的公有成员访问这个类，如Point类中的SetPoint（int,int）

●受保护成员：

只能由类本身及其派生类的函数访问（继承机制）

因此，使用私有数据隐藏由类对象操纵的数据，然后提供一些成员函数来访问这些数据，通常，使用和改变这些数据的能力和实现细节是被隐藏起来的。

3．类的构造举例——字符串类

要求：

能够修改字符串内容、获取字符串长度和内容。

//string_1.h

classString{

private:

//私有段，可以省略

intlength;//length和content为私有成员

char*contents;

public:

//公有段开始

intSet_Content（char*）;//设置字符串

intGet_Length（）;//取字符串长度

char*Get_Content（）;//取字符串内容

};

4．巩固练习——1（类声明）

3.2成员函数的定义（MemberFunction）

1．两种定义方式：

1在类体中声明，而在类外定义。

声明时，可以只指出函数所带参数的类型；在类外定义时，必须在函数名前缀上类名，以标明此函数所属的类。

如，上例中的String类中的三个成员函数可定义如下：

//string_1.cpp

//功能：

设置私有变量contents的值，同时计算其长度

intString:

:

Set_Content（char*conts）

{

inti=0;

contents=conts;//将字符串赋给私有变量contents

while（*conts++!

=‘\0’）

i++;//求字符串长度

length=i;//将长度赋给私有变量length

return1;

}

//功能：

获取字符串的长度

intString:

:

Get_Length（）

{

returnlength;//返回私有变量length

}

//功能：

获取字符串的值

char*String:

:

Get_Content（）

{

returncontents;//返回私有变量contents

}

注意：

Ø在所定义的成员函数名之前应缀上“类名:

:

”，如“String:

:

”

Ø函数的返回类型一定要与函数声明时的类型相匹配

2在类体内定义。

对于一些简单的成员函数，可以在类体中定义。

在类体内定义的成员函数被当作内联函数处理

2．内联函数的两种定义方式

1隐式定义——类体内定义

//point.h

classPoint{

intx,y;

public:

voidSetPoint（intvx,intvy）

intGetX（）{returnx;}

intGetY（）{returny;}

};

//string_1.h

classString{

private:

intlength;

char*contents;

public:

intSet_Content（char*）;

intGet_Length（）{returnlength;}

char*Get_Content（）{returncontent;}

};

2显式定义——类体外定义，函数最前面冠以关键字“inline”

//point.cpp

inlinevoidPoint:

:

SetPoint（intvx,intvy）

{

x=vx;y=vy;

}

【小结】

①所有成员函数都必须在类体内用函数原型加以声明，而其定义可在体外定义，也可在体内定义。

在体外定义时，成员函数名前应缀上“类名:

:

”

②成员函数与普通函数一样，可设置缺省参数。

3.3类与对象

1．类与对象的关系——整型int和整型变量i之间的关系

●类在概念上是一种抽象机制，它抽象了具有相同特征的一类对象的存储特性和操作特性；

在系统实现中，类是一种共享机制，它提供了本类对象共享的操作实现。

●对象和实例表达的是一个意思：

对象的创建过程就是类实例化的过程

●创建对象的两种方法

①在定义类的同时创建对象——全局对象（弊端：

）

//date.h

classDate{

intmonth,day,year;

public:

voidSet（int,int,int）;

voidPrint（）;

intGetYear（）;

intGetMonth（）;

intGetDay（）;

}tt;//同时创建对象tt

②在使用时定义对象——定义格式与一般变量的定义相同

如，Datett;//定义了tt是Date类的一个对象

2．类的使用

创建一个此类的对象，然后通过此对象访问类的公有成员函数，以便操作此对象的数据成员。

//point.h

classPoint{

intx,y;

public:

voidSetPoint（intvx,intvy）{x=vx;y=vy;}

intGetX（）{returnx;}

intGetY（）{returny;}

};

//point.cpp

……

//test.cpp

#include“iostream.h”

voidmain（）

{

Pointpt;//创建Point类的对象pt

pt.SetPoint（10,10）;//给Point类对象pt的私有成员赋值

cout<<”x=”<

cout<<”,y=”<

}

使用“.”操作符访问类的成员。

若定义的是指向此类对象的指针，则使用“->”操作符。

如：

voidmain（）

{

Pointpt,*pt1=&pt;

pt1->SetPoint（10,10）;

cout<<”x=”<GetX（）;

cout<<”,y=”<GetY（）;

}

3．名字解析

在调用成员函数时，通常使用缩写的形式，如

pt.SetPoint（10,10）pt.Point:

:

SetPoint（10,10）;

因此，可以在不同的类中定义名字相同的成员而不会产生二义性。

（函数重载？

）

如，//real_int_set.h

classRealSet{//定义一个实数集合类

intcard;

floatelems[16];

public:

voidPrint（）{//…}

};

classIntSet{//定义一个整数集合类

intcard;

intelems[16];

public:

voidPrint（）{//…}

};

//test.cpp

voidmain（）

{

IntSetis;

RealSetrs;

//...

is.Print（）;//调用的是InSet类中的Print（）

rs.Print（）;//调用的是RealSet类中的Print（）

}

4．巩固练习——2（成员的调用）

3.4构造函数与析构函数

目的：

构造函数初始化对象

析构函数删除对象

3.4.1基本用法

①函数名与类名相同，且没有返回类型。

//string_1.h

classString{

char*contents;

intlength;

public:

String（）;//声明构造函数，其名必须与类名相同，无类型说明

~String（）;//声明析构函数，在函数名前冠以“～”符号

voidSet_Content（char*）;

intGet_Length（）{returnlength;}

char*Get_Content（）{returncontent;}

};

//string_1.cpp

//构造函数的定义

String:

:

String（）

{

contents=0;//对其私有变量赋初值

length=0;

}

//析构函数的定义

String:

:

~String（）

{

}

//设置私有变量contents的值，同时计算其长度

intString:

:

Set_Content（char*conts）

{

inti=0;

contents=conts;//将字符串赋给私有变量contents

while（*conts++!

=‘\0’）

i++;//求字符串长度

length=i;//将长度赋给私有变量length

return1;

}

②在构造函数中一般只对数据成员做初始化工作，而不做赋初值以外的事情。

③构造函数不可显式地调用，当创建一个对象时，系统自动地调用。

在对象超出作用域范围之前，系统自动调用析构函数，释放对象的成员所占的空间。

String:

:

String（）

{

contents=0;//对私有变量赋初值

length=0;

cout<<”StringInitialized\n”;//在屏幕上输出对象已初始化的信息

}

String:

:

~String（）

{

cout<<”~Stringobject”<

}

voidmain（）

{

Stringstr1,str2;//定义String的两个对象str1和str2

str1.Set_Content（“Hello”）;//给两个对象的字串赋值

str2.Set_Content（“Welcome”）;

//在屏幕上输出两个对象的字串值

cout<<”\nstr1=”<

cout<<”\nstr2=”<

}

显示结果：

StringInitialized

StringInitialized

str1=Hello

str2=Welcome

~StringobjectWelcome

~StringobjectHello

Ø创建一个对象时，系统先为对象分配内存，然后调用构造函数初始化此对象的各数据成员（即：

设置对象的初始状态）

Ø释放一个对象时，系统先调析构函数，然后回收对象所占的内存。

如deletestr1;//①str1.~String（）②回收内存

析构对象的顺序与构造的顺序相反。

Ø若类中没有显式定义构造函数，在创建对象时，系统只分配内存，而不执行初始化工作，对象的各个数据将是随机值。

此时若对对象的数据进行操作，将导致结果错误！

（缺省的构造函数）

Ø若类中没有显式定义析构函数，系统会生成一个缺省的析构函数；但缺省的析构函数只回收对象所占有的空间，并不回收通过构造函数动态分配的内存（内存泄漏！

）（后讲！

）

④一个类有且只有一个析构函数。

3.5动态存储（new与delete）

newmalloc（sizeof（））;

deletefree（）;

1．优越性：

①new自动计算要分配的空间（根据数据类型）

②自动返回正确的指针类型，不必对返回指针进行类型转换

③可以用new将分配的对象初始化

2．new和delete的语法

基本形式：

名字指针＝newDataType（初始化值）;

delete名字指针;//被释放的存储空间的首址

①动态创建和释放一个对象

int*pi=newint（3）;/*int*pi=（int*）malloc（sizeof（int））;

*pi=3;

*/

deletepi;//free（pi）;

②创建和释放一组对象（数组）

int*pi=newint[10];

//...

delete[]pi;//释放整个数组所占用的空间

③创建和释放结构体对象

3．实例（1～4）

4．使用注意：

Ødelete前，必须判断指针是否为空，即if（p==NULL）orif（!

p）

以免同一空间进行多次撤消工作，导致非法操作！

Ønew和delete一般配对使用，即：

用new分配的存储，最好用delete释放

Ø动态分配的存储，必须显式删除（delete/free），系统不会自动回收，否则造成内存泄漏！

3.4.2构造函数的类型

1．带参数的构造函数

①在定义对象时，根据对象的初始状态不同，传递不同的状态参数给构造函数，从而实现不同对象的初始化状态不同。

如，

//test.cpp

classPoint{

intx,y;

public:

Point（intvx,intvy）;//声明带参数的构造函数

voidoffset（intax,intay）;

};

Point:

:

Point（intvx,intvy）

{

x=vx;//用传递进来的参数对私有变量x,y赋初值

y=vy;

}

voidPoint:

:

offset（intax,intay）

{

x+=ax;//对私有变量增值x=x+ax;

y+=ay;

}

voidmain（）

{

//定义对象pt1和pt2，并给构造函数传递实参

Pointpt1（5,5）,pt2（3,3）;

pt1.offset（10,15）;

pt2.offset（2,3）;

//......

}

2．缺省参数的构造函数

classPoint{

intx,y;

public:

Point（intvx=0,intvy=0）{x=vx;y=vy;}

//.......

};

voidmain（）

{

Pointp1;//不传递参数，全部用缺省值，即x=y=0

Point（10）;//只传递一个参数，vy用缺省值，即x=10,y=0

Point（10,20）;//传递两个参数，全部用实参，即x=10,y=20

}

Ø构造函数、一般的成员函数、一般的全局函数，都可以使用缺省参数。

3．拷贝构造函数

功能：

用同类的一个已存在的对象去初始化新创建的对象

两种形式：

①系统自动产生——缺省的拷贝构造函数，如

voidmain（）

{

Pointp1（10,20）;//调用Point（int,int）

Pointp2=p1;/*用已知对象初始化新对象

Pointp2（p1）;

调用缺省的拷贝构造函数*/

}

Ø实现机制：

将p1（已知对象）的每个数据成员的值，按照它们在类中说明的顺序，依次拷贝给新对象p2相应的数据成员，每次只拷贝一个数据，即“位模式拷贝”。

“位模式拷贝”产生的隐患：

#include

#include

classString{

intlength;

char*contents;

public:

String（char*s）;//声明构造函数

~String（）;//

//…

};

String:

:

String（char*s）//定义构造函数

{

if（s）

{

length=strlen（s）;

contents=newchar[length+1];//为字符串分配存储

strcpy（contents,s）;//字符串之间赋值

}

else

{

length=0;

contents=0;

}

}

String:

:

~String（）//定义析构函数

{

if（content）

deletecontents;//释放字符串contents所占空间

contents=0;//将指针置空

}

voidmain（）

{

Stringa（“Hust”）;

Stringb=a;

}//同一存储空间contents被delete两次

当类中声明有指针数据成员时，为避免程序隐患，最好自行编写拷贝构造函数。

②用户定义

格式：

A:

:

A（constA&）//A为类名

注：

只有一个参量，且参量是同类对象的引用变量（如A&）；多采用只读引用变量（如constA&），以免被引用对象被修改。

如

classPoint{

intx,y;

public:

Point（intvx,intvy）{x=vx;y=vy;}

Point（constPoint&rp）//定义一个拷贝构造函数

{x=rp.x;y=rp.y;}

};

classString{

intlength;

char*contents;

public:

String（char*s）;//声明构造函数

String（constString&rs）;//定义拷贝构造函数

~String（）;//

//…

};

String:

:

String（constString&rs）//定义拷贝构造函数

{

length=rs.length;

contents=newchar[length+1];//为字符串分配存储

strcpy（contents,rs.content）;//字符串之间赋值

}

voidmain（）

{

Stringa（“Hust”）;

Ab=a;

}

4．多构造函数（构造函数的重载）

在一个类中同时声明几个构造函数，以适应不同对象初始化目的。

如

classA{

public:

A（）;//不带参数的构造函数

A（int）;//只带一个int参数的～

A（int,char）;//带两个参数的～，一个整数，一个字符

A（float,char）;//带两个参数的～，一个浮点数，一个字符

A（constA&）;//拷贝构造函数

};

main（）

{

Aa;Ab

（1）;Ac（1,’c’）;

Ad（3.5,’d’）;Ae=a;

}

Ø注1：

多个构造函数之间，在参数的个数或类型上必须有所差别，否则系统调用时就会出现二义性

Ø注2：

若在定义多个构造函数时，使用了缺省参数，要防止二义性问题

如，classx

{

public:

x（）;

x（inti=0）;

};

main（）

{

xone（10）;//

xtwo;//?

?

?

}

3.4.3动态存储类的对象（new与delete）

1．创建和释放一个对象

Point*pt;//对象指针

pt=newPoint（10,10）;

//...

deletept;

<实例5>

2．创建和释放一组对象（数组）

Point*pt=newPoint[2];//对象数组

//...

delete[]pt;

Ø对数组动态分配存储时，不能同时对数组中的元素进行初始化。

若要实现对象数组中元素的初始化，可按下面两种方法：

①在类中定义不带参数的构造函数或全部带缺省参数的构造函数（实例6）

②在类中定义一个成员函数专门用来完成初始化功能；对象数组被创建后，通过调用此函数来对数组中的对象元素进行初始化

Ø对象数组的初始化方法同基本类型的数组

如，inta[2];a[0]=1;Aa[2];a[0]=A

（1）;

inta[3]={1,2,3};Aa[3]={A

（1）,A（1,’a’）,a[0]};

Ø若创建多维数组，必须提供所有维的大小。

如

int*qi=newint[2][3][5];

int*qi=newint[][3][5];//×

<参看教材【例3.18】>

3．使用注意：

Ø对简单的数据类型，以及没有显示定义构造函数和析构函数的类，两种管理内存的方式可以混合使用，即new分配的内存可用free释放，malloc分配的内存可用delete释放。

但若一个类显示定义了构造和析构函数，则最好用new和delete分配和释放内存。

Ø动态分配的存储，必须显式删除（delete/free），否则造成内存泄漏！

3.4.4小结

构造函数和析构函数是一种特殊的成员函数，其个性：

①都没有返回类型，即在定义时不需指出类型

②构造函数可以有缺省参数，但要注意避免二义性

③构造函数可重载，但析构函数不可重载（唯一性）

④构造函数不可显式调用，但析构函数可以

⑤当创建（定义）对象时，系统自动调用构造函数；当删除对象时，系统自动地调用析构函数（C++新特点：

提供了自动回收和显式回收两种内存管理方式）

⑥都不能被继承

⑦析构函数可以是虚的（virtual），但构造函数不行

3.4.5巩固练习

Ø练习1——改错（1－6）

Ø练习2——成员的访问和对象的定义：

2

Ø练习3——写出输出结果：

1

看懂教材第3章所有例子！

重点：