第3章-类与对象(二)

第3章类和对象2/3/20231面向对象程序设计技术本章主要介绍：类和对象的基本概念构造函数与析构函数对象数组、对象指针及引用

string类向函数传递对象对象的赋值和复制静态成员友元类的组合常量对象及常量成员3.3对象数组与对象指针3.3.1对象数组1、定义每一数组元素都是对象的数组声明：类名数组名[元素个数]；访问方法：通过下标访问数组名[下标].成员名2、对象数组初始化数组中每一个元素对象被创建时，系统都会调用类构造函数初始化该对象。对类对象数组中的元素初始化，必须通过该类的构造函数来进行。通过初始化列表赋值。例：

PointA[2]={Point(1,2),Point(3,4)};若在定义对象数组时，不想立即对数组中对象赋初值，其构造函数中必须含有一个不带参数的或是缺省参数的构造函数。3.3对象数组与对象指针不声明构造函数，则采用缺省构造函数。（注意：全局或静态对象的数据成员的值为0，局部（动态）对象的数据成员的值为随机的。）各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。当数组中每一个对象被删除时，系统都要调用一次析构函数。3.3对象数组与对象指针例3.3.1对象数组应用举例//Point.hclass

Point{public:

Point();Point(intxx,intyy);~Point();voidMove(intx,inty);intGetX(){returnX;}intGetY(){returnY;}private:intX,Y;};3.3对象数组与对象指针#include<iostream.h>#include"Point.h"Point::Point(){X=Y=0;cout<<"DefaultConstructorcalled."<<endl;}Point::Point(intxx,intyy){X=xx;Y=yy;cout<<"Constructorcalled."<<endl;}Point::~Point(){cout<<"Destructorcalled."<<endl;}voidPoint::Move(intx,inty){X=x;Y=y;}7#include<iostream.h>#include"Point.h"intmain(){cout<<"Enteringmain..."<<endl;

Point

A[2];for(inti=0;i<2;i++)

A[i].Move(i+10,i+20);cout<<"Exitingmain..."<<endl;

return0;}8运行结果：Enteringmain...DefaultConstructorcalled.DefaultConstructorcalled.Exitingmain...Destructorcalled.Destructorcalled.9例3.3.2对象数组应用举例classPoint{public:Point(intxx,intyy){X=xx;Y=yy;}……private:intX,Y;};main(){Pointpoint1(3,4);……Pointpoint2[20];……}正确否？出错！因为没有无参构造函数3.3对象数组与对象指针classPoint{public:Point(){x=y=0;}Point(intxx,intyy){X=xx;Y=yy;}……private:intX,Y;};main(){Pointpoint1(3,4);……Pointpoint2[20];……}正确否？正确！3.3对象数组与对象指针例3.3.2对象数组应用举例3.3.2对象指针1.用指针访问单个对象成员声明对象指针的一般语法格式

类名*对象指针名;当用指向对象的指针来访问对象成员时,要用“->”操作符。例3.3.3对象指针的使用。3.3对象数组与对象指针 #include<iostream.h> classexe{intx; public: voidset_a(inta){x=a;} voidshow_a(){cout<<x<<endl;}}; voidmain() {exeob,*p;//声明类exe的对象ob和类exe的对象指针p ob.set_a(2); ob.show_a();//利用对象名访问对象的成员

p=&ob;//将对象ob的地址赋给对象指针p

p->show_a();//利用对象指针访问对象的成员 }3.3对象数组与对象指针3.3对象数组与对象指针2.用对象指针访问对象数组例如将例3.3.3的main()改写为:voidmain() {exeob[2],*p; ob[0].set_a(10);ob[1].set_a(20);p=ob; p->show_a(); p++; p->show_a(); }3.3.3自引用指针thisC++提供了一个特殊的对象指针——this指针;this指针为成员函数所属对象的指针,指向对象的地址;this指针是一种隐含指针，隐含于每个类的成员函数中,即调用某成员函数时，都将自动产生一个this指针。this指针可以隐式调用——即在类内部直呼其名（前面介绍的所有例子）——通常均采用此种方法。显式调用this指针的格式：this->成员名注意：this指针是系统自定义的，用户不能再定义3.3对象数组与对象指针3.3.3自引用指针this例3.3.4this指针的引例。#include<iostream.h>classA{intx;public:A(intx1){x=x1;}voiddisp(){cout<<"x="<<x<<endl;}};main(){Aa(1),b(2);cout<<"a:";a.disp();cout<<"b:";b.disp();return0;}相当于this->x相当于this->x3.3对象数组与对象指针例3.3.5显示this指针的值。#include<iostream.h>classA{intx;public:A(intx1){x=x1;}voiddisp(){cout<<"\nthis="<<this<<"whenx="<<this->x;}};main(){Aa(1),b(2),c(3);a.disp();b.disp();c.disp();return0;}3.3对象数组与对象指针1、串的基本概念1)串(又称字符串)是由n(n≥0)个字符组成的有限序列。（它是数据元素为单个字符的特殊线性表。）记为：s=“s0,s1,……,sn-1”(n≥0)

串名串值（用“”括起来）２)串长串中字符的个数（n≥0）。３)空串串中字符的个数为0时称为空串。４)空白串由一个或多个空格符组成的串。５)子串串S中任意个连续的字符序列叫S的子串;S叫主串。3.4string类６)子串位置子串的第一个字符在主串中的序号。７)字符位置字符在串中的序号。８)串相等串长度相等，且对应位置上字符相等。（即两个串中的字符序列一一对应相等。）空串和空白串的区别空串(NullString)是指长度为零的串；而空白串(BlankString),是指包含一个或多个空白字符‘’(空格键)的字符串.注：串与字符的区别“a”串，长度为１的串。（它不仅要存储字符‘a’，还要存储该串的长度数据１）‘a’字符a。(只存储字符‘a’)

3.4string类2、C-串结构每个字符占据1个字节一个C-串是一个字符序列,用来表示各种名字或者文字说明C-串的字符序列的最后总是添加有一个结束标志.即在6个字符的字串(“Hello!”)其空间存储有7个字节右边三图是不同细节的同一空间结构描述’H’’e’’l’’l’’o’’!’’\0’72101108108111330010010000110010101101100011011000110111100100001000000003.4string类知道了C-串首地址,即可知道整个串,所以可以藉字符首址(字符指针)来操作C-串,但要注意，串的第一个字符与整个串的操作不同,如,C-串的输出操作:

char*str=”Hello”;cout<<*str<<endl;//显示Hcout<<str<<endl;//显示Hello3.4string类3、C-串配备专门操作库函数C-串不能直接比较：

cout<<(“join”==”join”?””:”not“)<<”equal\n”;//字面值比较

char*str1=”good”;

char*str2=”good”;cout<<(str1==str2?””:”not“)<<”equal\n”;//字符指针比较

charbuffer1[6]=”Hello”;

charbuffer2[6]=”Hello”;cout<<(buffer1==buffer2?””:”not“)<<”equal\n”;//字符数组比较结果：notequalnotequalnotequal3.4string类所以C-串配备专门操作库函数:strcpy(s1,s2);//从s2拷贝到s1strcmp(s1,s2);//比较s1与s2strcat(s1,s2);//连接s2到s1strrev(s);//将s倒排strset(s,‘c’);//将s全置为cstrstr(s,“ell”);//查找s中的子串strchr(s,‘c’);//查找s中的字符等等3.4string类4、字符指针操作C-串的不安全性char*str1;char*str2=new

char[5];strcpy(str2,”ugly”);strcpy(str1,str2);//错:str1没有空间可储strcpy(str2,”Hello”);//错:str2空间不够大str2=”Hello”;//错：原来的”ugly”空间脱钩，导致内存泄漏根源：复制操作须以足够的目的地空间为前提，而所有C-串操作的空间调配都是人为安排的，C-串库函数一概不管3.4string类C++支持两种类型的字符串时，一是C语言介绍的串，另一种是更方便的字符串类型，即字符串类string，string类提供了对字符串处理所需要的操作。3.4string类5、string类和对象使用string类，需要包含头文件#include<string>定义串对象格式，string对象1，对象2……string串的运算符：+、=、+=、==、!=、<、<=、>、>=、[]、<<、>>例3.4.1：stringa,s1="Hello";strings2="123";a=s1;//copycout<<(a==s1?"":"not")<<"equal\n";//comparecout<<a+s2<<endl;//concatenatereverse(a.begin(),a.end());cout<<a<<endl;//reversecout<<a.replace(0,9,9,'c')<<endl;//setcout<<(s1.find("ell")!=-1?"":"not")<<"found\n";//findstringcout<<(s1.find('c')!=-1?"":"not")<<"found\n";//findchar3.4string类6、C-串和string输入：cin>>的读入方式总是将前导的空格（所谓空格，即包括空格、回车、水平或垂直制表符等）滤掉，将单词读入，在遇到空格时结束本次输入getline总是将行末的回车符滤掉，将其整行输入对字串”Hello,Howareyou?”的两种输入方式for(strings;cin>>s;)cout<<s<<”“;cout<<endl;

strings;getline(cin,s);cout<<s<<endl;3.4string类3.5向函数传递对象3.5.1使用对象作为函数参数例3.4.2使用对象作为函数参数。#include<iostream.h>class

aClass{public:aClass(intn){i=n;}voidset(intn){i=n;}intget(){returni;}private:inti;};voidsqr(aClass

ob){ob.set(ob.get()*ob.get());cout<<"copyofobjhasivalueof";cout<<ob.get()<<"\n";}main(){aClassobj(10);sqr(obj);cout<<"But,obj.iisunchangedinmain:";cout<<obj.get();return0;}3.5向函数传递对象先拷贝再使用3.5.2使用对象指针作为函数参数

例3.5.1使用对象指针作为函数参数。

#include<iostream.h>classaClass{public: aClass(intn){i=n;} voidset(intn){i=n;} intget(){returni;}private: inti;};3.5向函数传递对象voidsqr(aClass

*ob){ob->set(ob->get()*ob->get());cout<<"Copyofobjhasivalueof";cout<<ob->get()<<"\n";}main(){aClassobj(10);sqr(&obj);cout<<"Now,obj.iinmain()hasbeenchanged:";cout<<obj.get()<<"\n";return0;}3.5向函数传递对象传地址，直接引用3.5向函数传递对象3.5.3使用对象引用作为函数参数例3.5.2使用对象引用作为函数参数。#include<iostream.h>classaClass{public: aClass(intn){i=n;} voidset(intn){i=n;} intget(){returni;}private: inti;};voidsqr(aClass&ob){ob.set(ob.get()*ob.get());cout<<"Copyofobjhasivalueof";cout<<ob.get()<<"\n";}main(){aClassobj(10);sqr(obj);cout<<"Now,obj.iinmain()hasbeenchanged:";cout<<obj.get()<<"\n";return0;}3.5向函数传递对象用别名，直接引用3.6.1对象的赋值语句变量可以直接赋值，如intxy=10;x=y;两个同类型的对象是否可以直接赋值呢？例3.6.1所示3.6对象的赋值和复制#include<iostream.h>classabc{ public:voidinit(inti,intj){a=i;b=j;}voidshow(){cout<<a<<""<<b<<endl;} private:inta,b;}; main() {abco1,o2; o1.init(12,34);

o2=o1;

//将对象o1数据成员的值赋给对象o2 o1.show(); o2.show(); return0; }将对象o1的所有数据成员对应地赋值给对象o2的所有数据成员(这里实质上调用了缺省赋值运算符函数)3.6对象的赋值和复制赋值说明：两个对象类型必须一致赋值过程是，将一个对象的所有数据成员的值复制给另外一个对象对应的数据成员思考：仅仅是数据成员的简单复制，是否适合所有类型的对象赋值？3.6对象的赋值和复制3.6.2拷贝构造函数拷贝构造函数是一种特殊的构造函数,其形参是本类对象的引用。其作用是使用一个已经存在的对象去初始化另一个同类的对象。拷贝构造函数具有以下特点:因为该函数也是一种构造函数,所以其函数名与类名相同,并且该函数也没有返回值类型。该函数只有一个参数,并且是同类对象的引用。每个类都必须有一个拷贝构造函数。程序员可以根据需要定义特定的拷贝构造函数,以实现同类对象之间数据成员的传递。如果程序员没有定义类的拷贝构造函数,系统就会自动生成产生一个缺省的拷贝构造函数。3.6对象的赋值和复制3.6.2拷贝构造函数调用拷贝构造函数的一般形式：类名对象2（对象1）类名对象2=对象1调用拷贝构造函数的3中情况用一个对象去初始化另一个对象时函数调用时，实参对象传递给形参对象函数返回时，返回值是类类型时。3.6对象的赋值和复制自定义拷贝构造函数自定义拷贝构造函数的一般形式如下:类名::类名（类名&对象名）{//拷贝构造函数的函数体}例3.6.2自定义拷贝构造函数的使用。3.6.2拷贝构造函数3.6对象的赋值和复制#include<iostream.h>classCoord {public:Coord(inta,intb)//构造函数{x=a;y=b;cout<<"Usingnormalconstructor\n";}

Coord(constCoord&p)//拷贝构造函数{x=2*p.x;y=2*p.y;cout<<"Usingcopyconstructor\n";}voidprint(){cout<<x<<""<<y<<endl;}private:intx,y;};main(){Coordp1(30,40);//定义对象p1,调用了普通的构造函数Coordp2(p1);//以“代入”法调用拷贝构造函数,用对象p1初始化对象p2p1.print();p2.print();return0;}3.6对象的赋值和复制在默认拷贝构造函数中，拷贝的策略是逐个成员依次拷贝。但是，一个类可能会拥有资源，当其构造函数分配了一个资源（例如堆内存）的时候，会发生什么？如果拷贝构造函数简单地制作了一个该资源的拷贝，而不对它本身分配，就得面临一个麻烦的局面：两个对象都拥有同一个资源。当对象析构时，该资源将经历两次资源返还。3.6对象的赋值和复制3.6.3浅拷贝与深拷贝浅拷贝实现对象间数据元素的一一对应复制。默认的拷贝函数都是浅拷贝深拷贝当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指的对象进行复制。3.6对象的赋值和复制下面的程序描述了Person对象被浅拷贝后，面临析构时的困惑：#include<iostream.h>#include<string.h>classPerson{public:Person(char*pN){cout<<"Constructing"<<pN<<endl;pName=newchar[strlen(pN)+1];3.6对象的赋值和复制

if(pName!=0)strcpy(pName,pN);}~Person(){cout<<"Destructing"<<pName<<endl;pName[0]='\0';deletepName;}protected:char*pName;};443.6对象的赋值和复制

voidmain(){Personp1("Randy");Personp2=p1;//即Personp2(p1);，调用默认拷贝构造函数，}//p2与p1完全一样运行结果：45Destructing葺葺葺葺葺程序出错！ConstructingRandy创建p1对象时输出DestructingRandy主函数结束时，析构p2主函数结束时，析构p13.6对象的赋值和复制46内存逻辑示意图：3.6对象的赋值和复制浅拷贝与深拷贝在上例基础上，增加一个Person类的深拷贝构造函数：#include<iostream.h>#include<string.h>classPerson{public:Person(char*pN);Person(Person&p);~Person();protected:char*pName;};Person::Person(char*pN){cout<<"Constructing"<<pN<<endl;pName=newchar[strlen(pN)+1];if(pName!=0)strcpy(pName,pN);}Person::Person(Person&p){cout<<"Copying"<<p.pName<<"intoitsownblock\n";pName=newchar[strlen(p.pName)+1];if(pName!=0)strcpy(pName,p.pName);}48Person::~Person(){cout<<"Destructing"<<pName<<endl;pName[0]='\0';deletepName;}voidmain(){Personp1("Randy");Personp2=p1;//即Personp2(p1);}49运行结果：ConstructingRandyCopyingRandyintoitsownblockDestructingRandyDestructingRandy503.7静态成员3.7.1静态数据成员在一个类中,若将一个数据成员说明为static,这种成员称为静态数据成员。与一般的数据成员不同,无论建立多少个类的对象,都只有一个静态数据的拷贝。从而实现了同一个类的不同对象之间的数据共享。定义静态数据成员的格式如下:

static数据类型

数据成员名;

例3.7.1静态数据成员的使用引例。解决共享全局变量的问题#include<iostream.h>#include<string.h>classStudent{public:Student(char*name1,char*stu_no1,floatscore1); ~Student();voidshow();//输出姓名、学号和成绩 voidshow_count_sum_ave();//输出学生人数、总成绩和平均成绩private: char*name;//学生姓名 char*stu_no;//学生学号 floatscore;//学生成绩

staticintcount;//静态数据成员,统计学生人数

staticfloatsum;//静态数据成员,统计总成绩

staticfloatave;//静态数据成员,统计平均成绩};Student::Student(char*name1,char*stu_no1,floatscore1){name=newchar[strlen(name1)+1];strcpy(name,name1);stu_no=newchar[strlen(stu_no1)+1];strcpy(stu_no,stu_no1); score=score1;++count;//累加学生人数

sum=sum+score;//累加总成绩

ave=sum/count;//计算平均成绩}Student::~Student(){delete[]name;delete[]stu_no;

--count;

sum=sum-score;}相当于this->x修改共享变量voidStudent::show(){cout<<"\nname:"<<name;cout<<"\nstu_no:"<<stu_no;cout<<"\nscore:"<<score;}voidStudent::show_count_sum_ave(){cout<<"\ncount:"<<count;//输出静态数据成员countcout<<"\nsum:"<<sum;//输出静态数据成员sumcout<<"\nave:"<<ave;//输出静态数据成员ave}intStudent::count=0;//静态数员count初始化floatStudent::sum=0.0;//静态数员sum初始化floatStudent::ave=0.0;//静态数员ave初始化初始化格式如下：<类型><类名>::<静态数据成员名>=<值>；voidmain(){ Studentstu1("Liming","990201",90); stu1.show(); stu1.show_count_sum_ave();Studentstu2("Zhanghao","990202",85);stu2.show(); stu2.show_count_sum_ave();}3.7静态成员

3.7.2静态成员函数引用类中说明的静态数据成员，但不能直接引用非静态数据成员定义静态成员函数的格式如下:static返回类型静态成员函数名（参数表）;与静态数据成员类似,调用公有静态成员函数的一般格式有如下几种:

类名::静态成员函数名(实参表)对象.静态成员函数名(实参表)对象指针->静态成员函数名(实参表)例3.7.2静态成员函数来访问静态数据成员。解决静态数据成员的访问问题#include<iostream.h>#include<string.h>classStudent{private: char*name;//学生姓名 char*stu_no;//学生学号 floatscore;//学生成绩

staticintcount;//静态数据成员,统计学生人数

staticfloatsum;//静态数据成员,统计总成绩public:Student(char*name1,char*stu_no1,floatscore1); ~Student();voidshow();//普通成员函数,输出姓名、学号和成绩staticvoidshow_count_sum();//静态成员函数,输出学生人数和总成绩};Student::Student(char*name1,char*stu_no1,floatscore1){name=newchar[strlen(name1)+1];strcpy(name,name1);stu_no=newchar[strlen(stu_no1)+1];strcpy(stu_no,stu_no1);score=score1;

++count;//累加学生人数

sum=sum+score;//累加总成绩}Student::~Student(){delete[]name;delete[]stu_no;

--count;

sum=sum-score;}相当于this->x修改共享变量voidStudent::show(){ cout<<"\nname:"<<name; cout<<"\nstu_no:"<<stu_no; cout<<"\nscore:"<<score;}voidStudent::show_count_sum()//静态成员函数{ cout<<"\ncount:"<<count;//输出静态数据成员cout<<"\nsum:"<<sum;//输出静态数据成员}intStudent::count=0;//静态数据成员初始化floatStudent::sum=0.0;//静态数据成员初始化voidmain(){Studentstu1("Liming","990201",90); stu1.show();

Student::show_count_sum();//使用类名访问静态成员函数Studentstu2("Zhanghao","990202",85); stu2.show();

stu2.show_count_sum();//使用对象stu2访问静态成员函数}3.7静态成员3.7.3通过普通指针访问静态成员例3.7.3通过指针访问类的静态数据成员。 #include<iostream.h>classmyclass{public:myclass()//构造函数,每定义一个对象,{++i;}//静态数据成员i加1

staticinti;//声明静态数据成员i };intmyclass::i=0;//静态数据成员i初始化,//不必在前面加staticmain(){int*count=&myclass::i;//声明一个int型指针,//指向类的静态成员myclassob1,ob2,ob3,ob4;cout<<"myclass::i="<<*count<<endl;//通过指针直接//访问静态数据成员return0;}3.7静态成员3.8友元

友元既可以是不属于任何类的一般函数,也可以是另一个类的成员函数,还可以是整个的类。3.8.1友元函数友元函数不是当前类的成员函数,而是独立于当前类的外部函数，但它可以访问该类的对象的所有成员,包括私有成员、保护成员和公有成员。友元函数的定义和调用与一般函数是一样的。例3.8.1友元函数的使用。#include<iostream.h>#include<string.h>classgirl{ public:girl(char*n,intd){name=newchar[strlen(n)+1];strcpy(name,n);age=d;}friend

voiddisp(girl&);//声明友元函数~girl(){delete[]name;}private:char*name;intage;};voiddisp(girl&x)//定义友元函数{cout<<"Girl\'snameis"<<<<",age:"<<x.age<<"\n";}voidmain(){girle("ChenXingwei",18);disp(e);//调用友元函数}在私有段和公有段都可3.8友元

3.8.2友元成员一个类的成员函数也可以作为另一个类的友元，这种成员函数不仅可以访问自己所在类对象中的所有成员,还可以访问friend声明语句所在类对象中的所有成员。这样能使两个类相互合作、协调工作,完成某一任务。例3.8.2一个类的成员函数作为另一个类的友元。#include<iostream.h>#include<string.h>classgirl;classboy{public:boy(char*n,intd){name=newchar[strlen(n)+1];strcpy(name,n);age=d;}voiddisp(girl&);//声明disp()为类boy的成员函数~boy(){deletename;}private:char*name;intage;};classgirl{public:girl(char*n,intd){name=newchar[strlen(n)+1];strcpy(name,n);age=d;}

friendvoidboy::disp(girl&);//声明类boy的成员函数disp()//为类girl的友元函数~girl(){deletename;}private:char*name;intage;};voidboy::disp(girl&x)//定义友元函数disp(){cout<<"Boy\'snameis"<<name<<",age:"<<age<<"\n";//访问boy类对象的成员cout<<"Girl\'snameis"<<<<",age:"<<x.age<<"\n";}//访问girl类对象的成员

通过对象访问私有成员的又一例外通过对象访问私有成员的又一例外voidmain() { boyb("ChenHao",25); girle("ZhangWei",18);

b.disp(e); }

程序运行结果如下:Boy'snameisChenHao,age:25Girl'snameis:ZhangWei,age:183.8友元3.8.3友元类一个类也可以作为另一个类的友元。例如:classY{//…};classX{//…

friendY;//声明类Y为类X的友元类//…};3.9对象成员

如果一个类的对象是另一个类的数据成员,则称这样的数据成员为对象成员。例如:classA{//...};classB{

Aa;//类A的对象a为类B的对象成员public://…};使用对象成员着重要注意的问题是对象成员的初始化问题,即类B的构造函数如何定义？例如有以下的类:classX{类名1对象成员名1;类名2对象成员名2;…类名n对象成员名n;};一般来说,类X的构造函数的定义形式为;X::X(形参表0):对象成员名1(形参表1),…,对象成员名i(形参表i),…,对象成员名n(形参表n){//…构造函数体}3.10常类型3.10.1常引用如果在说明引用时用const修饰,则被说明的引用为常引用。常引用的说明形式如下:const类型&引用名[=初值];或：类型const&引用名[=初值];例如:

inta=5;

constint&b=a;b是一个常引用,它所引用的对象不允许更改。例3.10.1常引用作函数形参。#include<iostream.h>intadd(

const

int&i