怎样使用类和对象课件

第3章怎样使用类和对象第3章怎样使用类和对象授课内容3.1利用构造函数对对象进行初始化3.2利用析构函数进行清理工作3.3调用构造函数和析构函数的顺序3.4对象数组3.5对象指针3.6公用数据的保护3.7对象的动态创建和释放3.8对象的赋值和复制2.9静态成员3.10友元3.11类模板授课内容3.1利用构造函数对对象进行初始化3.1利用构造函数对对象进行初始化3.1利用构造函数对对象进行初始化3.1利用构造函数对对象进行初始化作用构造函数：当一个对象被定义时会自动调用，用来对对象进行初始化。3.1利用构造函数对对象进行初始化作用classPoint{intm_nX;intm_nY;public:Point(intx,inty){m_nX=x;m_nY=y;cout<<"con"<<endl;}voidSetXY(inta,intb){m_nX=a;m_nY=b;}voidPrintXY(){cout<<m_nX<<","<<m_nY;}};p1m_nY：

m_nX：intmain(){Pointp1(10,20);Pointp2(13,15);

p1.SetXY(20,10);p2.PrintXY();return0;}1020p2m_nY：

m_nX：13152010classPointp1m_nY：m_nX：intma3.1利用构造函数对对象进行初始化声明格式：<类名>(<参数表>);程序中不能直接调用构造函数，在定义对象时，系统会自动调用构造函数3.1利用构造函数对对象进行初始化声明格式：3.1利用构造函数对对象进行初始化构造函数与类同名没有返回值，原型中也没有void。3.1利用构造函数对对象进行初始化构造函数与类同名3.1利用构造函数对对象进行初始化构造函数可以重载。classPoint{private: intm_nX; intm_nY;public:

Point(inta,intb){m_nX=a;m_nX=b;} voidSetXY(inta,intb){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;} ~Point(){}};Point(){m_nX=0;m_nX=0;}Pointp1;Pointp2(10,20);Pointp4(20);Pointp3();在创建对象时，必须有可匹配的构造函数被调用，如果无匹配的构造函数，则报错。3.1利用构造函数对对象进行初始化构造函数可以重载。Poi3.1利用构造函数对对象进行初始化构造函数可以带有默认参数。classPoint{private: intm_nX; intm_nY;public:

Point(){m_nX=0;m_nX=0;} Point(inta,intb){m_nX=a;m_nX=b;} voidSetXY(inta,intb){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;} ~Point(){}};Point(inta=0,intb=0){m_nX=a;m_nX=b;}Pointp1;Pointp2(10,20);Pointp3(20);3.1利用构造函数对对象进行初始化构造函数可以带有默认参数3.1利用构造函数对对象进行初始化构造函数是成员函数，函数体可写在类体内也可以写在类体外。classPoint{private: intm_nX; intm_nY;public: Point(inta=0,intb=0); voidSetXY(inta,intb); voidPrintXY(); ~Point(){}};//point.cpp的内容Point::Point(inta=0,intb=0){m_nX=a;m_nY=b;}voidPoint::SetXY(inta,intb){m_nX=a;m_nY=b;}voidPoint::PrintXY(){cout<<m_nX<<","<<m_nY;}(inta,intb)//point.h的内容3.1利用构造函数对对象进行初始化构造函数是成员函数，函数3.1利用构造函数对对象进行初始化classPoint{private: intm_nX; intm_nY;public:

voidSetXY(inta,intb){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;} ~Point(){}};//系统为我们自动产生的构造函数，我们看不见它

intmain(){ Pointp; p.PrintXY(); return0;}Point(){}3.1利用构造函数对对象进行初始化classPoint/3.1利用构造函数对对象进行初始化classPoint{private: intm_nX; intm_nY;public:

Point(inta,intb){m_nX=a;m_nX=b;} voidSetXY(inta,intb){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;} ~Point(){}};intmain(){ Pointp; p.PrintXY(); return0;}3.1利用构造函数对对象进行初始化classPointi3.1利用构造函数对对象进行初始化如果一个类你没有定义构造函数，那么系统会为你定义一个构造函数，该构造函数的参数表和函数体为空；如果你定义了一个构造函数，则系统不会为你定义任何构造函数。3.1利用构造函数对对象进行初始化如果一个类你没有定义构造数据成员的初始化在构造函数的函数体中初始化classPoint{private: intm_nX;intm_nY;public: Point(inta=0,intb=0){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;}};p1m_nY：

m_nX：1020intmain(){ Pointp1(10,20); p1.PrintXY(); return0;}数据成员的初始化在构造函数的函数体中初始化p1m_nY：m数据成员的初始化在构造函数头部初始化格式：类名::构造函数(参数表):m1(v1),m2(v2),…{函数体}初始化列表数据成员的初始化在构造函数头部初始化初始化列表classPoint{private: intm_nX; intm_nY;public: Point(inta=0,intb=0) {m_nX=a;m_nY=b;} voidSetXY(inta,intb) {m_nX=a;m_nY=b;} voidPrintXY() {cout<<m_nX<<","<<m_nY;}};Point(inta=0,intb=0):m_nX(a),m_nY(b)

{}classPointPoint(inta=0,i数据成员的初始化classPerson{private: charm_strName[20]; intm_nAge; boolm_nSex;public: Person(): m_strName("XXX"),m_nAge(

0),m_nSex(0) {}};Person():m_nAge(

0),m_nSex(0){strcpy(m_strName,"XXX");}规则：能在初始化列表中初始化的成员，尽量在初始化列表中初始化。数据成员的初始化classPersonPerson()3.2利用析构函数进行清理工作3.2利用析构函数进行清理工作3.2利用析构函数进行清理工作作用：将要释放某个对象所占据的存储空间之前，该对象的析构函数会被自动调用，来进行一些清理工作。声明格式：~类名();3.2利用析构函数进行清理工作作用：classPoint{intm_nX;intm_nY;public:Point(intx,inty){m_nX=x;m_nY=y;cout<<"con"<<endl;}voidSetXY(inta,intb){m_nX=a;m_nY=b;}voidPrintXY(){cout<<m_nX<<","<<m_nY;}~Point(){cout<<"destroy"<<endl;}};p1m_nY：

m_nX：intmain(){Pointp1(10,20);Pointp2(13,15);

p1.SetXY(20,10);p2.PrintXY();return0;}1020p2m_nY：

m_nX：13152010concon13,15destroydestroyclassPointp1m_nY：m_nX：intma3.2利用析构函数进行清理工作classArray{private: int*m_pArray; intm_nSize;public: Array(intn) { m_nSize=n; m_pArray=newint[n]; } ~Array(){}};intmain(){ Arraya(4);

return0;}0X1000am_nSize：

m_pArray：

0X100043.2利用析构函数进行清理工作classArrayint3.2利用析构函数进行清理工作classArray{private: int*m_pArray; intm_nSize;public: Array(intn) { m_nSize=n; m_pArray=newint[n]; }};intmain(){ Arraya(4);

return0;}~Array(){delete[]m_pArray;}0X1000am_nSize：

m_pArray：

0X100043.2利用析构函数进行清理工作classArrayint3.2利用析构函数进行清理工作析构函数与类同名，只是在前面添加了符号~。析构函数没有返回值，原型中也没有void。析构函数没有参数，一个类只能有一个析构函数，析构函数不能被重载析构函数的函数体可写在类体内，也可写在类体外。将要释放某个对象所占据的存储空间之前，系统自动调用析构函数。析构函数也可以被程序显示调用。3.2利用析构函数进行清理工作析构函数与类同名，只是在前面析构函数classPoint{private: intm_nX; intm_nY;public: Point(inta=0,intb=0){m_nX=a;m_nY=b;} voidSetXY(inta,intb){m_nX=a;m_nY=b;} voidPrintXY(){cout<<m_nX<<","<<m_nY;}};对于一个类，如果没有显示定义析构函数，编译器自动产生一个函数体为空的析构函数。析构函数classPoint3.2利用析构函数进行清理工作对于一个类，如果没有显示定义构造函数，编译器自动为该类产生一个构造函数。对于一个类，如果没有显示定义析构函数，编译器自动产生为该类一个析构函数。一个设计合理的类，一般至少要显示定义一个构造函数。至于是否要显示定义析构函数，可根据需要确定，如果该类的对象占据的存储空间释放时不必要做什么清理工作，可以不必定义析构函数。3.2利用析构函数进行清理工作对于一个类，如果没有显示定义3.8对象的赋值与复制3.8对象的赋值与复制拷贝构造函数在创建对象时，必须有一个匹配的构造函数被调用，如果无匹配的构造函数，则报错。classPoint{private: intm_nX;intm_nY;};Pointp2;Pointp1(10,30);inta=5;intb(a);Pointp3(p1);public:Point(inta=0,intb=0):m_nX(a),m_nY(b){}拷贝构造函数在创建对象时，必须有一个匹配的构造函数被调用，如classPoint{private: intm_nX;intm_nY;public: Point(inta=0,intb=0):m_nX(a),m_nY(b){} Point(constPoint&p) {m_nX=p.m_nX;m_nY=p.m_nY;}};Pointp1(10,30);Pointp2(p1);Pointp3=p1;等价于Pointp3(

p1);Point(constPoint&p):m_nX(p.m_nX),m_nY(p.m_nX){}classPointPoint(constPoint拷贝构造函数拷贝构造函数拷贝构造函数是一种特殊的构造函数，其形参是本类对象的常引用。它的作用是用一个已经存在的对象初始化一个新的同类对象。拷贝构造函数拷贝构造函数拷贝构造函数格式：<类名>::<拷贝构造函数名>(const<类名>&<引用名>)特点：是一种构造函数。参数为本类对象的常引用。类名拷贝构造函数格式：类名拷贝构造函数拷贝构造函数的调用:明确表示由另一个对象对要创建的对象进行初始化时。Pointp2(p1);

Pointp3=p1;Pointp4; p4=p1;//调用构造函数//不调用构造函数拷贝构造函数拷贝构造函数的调用://调用构造函数//不调用构拷贝构造函数classPoint{private: intm_nX;intm_nY;public: Point(inta=0,intb=0) {m_nX=a;m_nY=b;} voidShow() {cout<<m_nX<<m_nY;}};intmain(){ Pointp1(10,30);

Pointp2(p1);p2.Show();return0;}拷贝构造函数classPointintmain()拷贝构造函数每个类都必须有一个拷贝构造函数，如果没有显式定义拷贝构造函数，则编译系统自动生成一个拷贝构造函数，作为公有成员。系统自动生成的拷贝构造函数的函数体不为空，拷贝的策略是逐个成员依次拷贝。所以对一些简单的类我们没有必要写拷贝构造函数，系统自动生成的拷贝构造函数就可以以达到我们的目的。（前面的Point类）拷贝构造函数每个类都必须有一个拷贝构造函数，如果没有显式定义classArray{private: int*m_pArray; intm_nSize;public: Array(intn):m_nSize(n) { m_pArray=newint[n]; for(inti=0;i<n;++i) {m_pArray[i]=i;} } ~Array() {delete[]m_pArray;}};intmain(){ Arrayp1(4); Arrayp2(p1);

return0;}0X1000p1m_nSize：

m_pArray：p2m_nSize：

m_pArray：03124

0X10004

0X1000classArrayintmain()0X1000p1m拷贝构造函数p1到p2的浅拷贝拷贝构造函数p1到p2的浅拷贝拷贝构造函数p1到p2的深拷贝拷贝构造函数p1到p2的深拷贝拷贝构造函数在系统自动生成的拷贝构造函数中，拷贝的策略是逐个成员依次拷贝。但是，当一个类拥有资源(例如堆内存)的时候，默认拷贝构造函数只能进行浅拷贝，并不能拷贝资源。解决方法：定义自己的拷贝构造函数，不使用默认拷贝构造函数，使之不但拷贝成员，也拷贝资源。拷贝构造函数在系统自动生成的拷贝构造函数中，拷贝的策略是逐个classArray{private: int*m_pArray; intm_nSize;public: Array(intn):m_nSize(n) { m_pArray=newint[n]; for(inti=0;i<n;++i) {m_pArray[i]=i;} } Array(constArray&a):m_nSize(a.m_nSize) { m_pArray=newint[m_nSize]; for(inti=0;i<m_nSize;++i) {m_pArray[i]=a.m_pArray[i];} } ~Array(){delete[]m_pArray;}};intmain(){Arrayp1(4);Arrayp2(p1);return0;}p1m_nSize：

m_pArray：p2m_nSize：

m_pArray：4

0X10004

0X20000X100003120X20000312classArrayintmain()p1m_nSizeclassStack{ int*m_Elem; intm_nTop; constintm_nSize;

public: Stack(intsize):m_nTop(0),m_nSize(size) {m_Elem=newint[size];} ~Stack(){delete[]m_Elem;} boolIsEmpty(){returnm_nTop==0;}

boolIsFull(){returnm_nTop==m_nSize;}

boolPush(inte); boolPop(int&e);};s1m_nSize：5

m_Elem：

0X1000Stacks1(5);m_nTop：00X1000Stacks2(s1);Stack(constSattic&s);classStacks1m_nSize：5m_Elem：3.9静态成员3.9静态成员静态数据成员//test.h的内容classTest{public: inta; intb; Test(intx,inty);};//test.cpp的内容#include"test.h"Test::Test(intx,inty) :a(x),b(y){}//main.cpp的内容#include"test.h"intmain(){Testt1(1,2),t2(3,4);cout<<t1.a<<t2.a;cout<<t1.b<<t2.b;return0;}staticintb;Test(intx);Test::Test(intx) :a(x){}

b(10)t1a(1)t2a(3)Testt1(1),t2(3);cout<<Test::b;intTest::b=10;//必需静态数据成员//test.h的内容//test.cpp的内容静态数据成员使用静态数据成员可以实现多个对象之间的数据共享。使用静态数据成员可以节省内存，对多个对象来说，静态数据成员只存储一处，供所有对象使用。使用静态数据成员还不会破坏封装性的原则，保证了安全性。如果静态数据成员是公有的，在类外面可以通过类名::静态数据成员名直接访问。静态数据成员的值对每个对象都是一样的,但它的值是可以更新的。静态数据成员使用静态数据成员可以实现多个对象之间的数据共享。静态数据成员classAcount//帐户{ doubleamount;}；ClassCurrentAcount:publicAcount//活期{ staticdoubleinterest;};ClassTimeAcount:publicAcount//定期{ staticdoubleinterest;};doubleCurrentAcount::interest=0.3;doubleTimeAcount::interest=0.7;静态数据成员classAcount//帐户classMyclass{ inta,b; staticintsum;public: Myclass(intx,inty); voidGet();};intMyclass::Sum=0;Myclass::Myclass(intx,inty):a(x),b(y){sum+=a+b;}voidMyclass::Get(){cout<<a<<b<<sum<<endl;}intmain(){MyclassM(1,2);MyclassN(7,8); M.Get();N.Get();return0;}classMyclass静态成员函数在成员函数原形前面加上static，就为静态成员函数。非静态成员函数和静态成员函数的区别：非静态成员函数里有this指针，既可以访问非静态数据成员，又可以访问静态数据成员。静态成员函数里无this指针，只可以访问静态数据成员。静态成员函数在成员函数原形前面加上static，就为静态成员静态成员函数//test.h的内容classTest{prvate: inta staticintb;public: Test(intx);

};//main.cpp的内容intmain(){Testt1(1);cout<<t1.a;//错

cout<<t1.b;//错

return0;}//test.cpp的内容#include"test.h"intTest::b=10;//必需Test::Test(intx):a(x){}intGetA();staticintGetB();intTest::GetA(){returna;}cout<<t1.GetA();cout<<t1.GetB();cout<<Test::GetB();cout<<Test::GetA();intTest::GetB(){returnb;}returna+b;}returna+b;}错误静态成员函数//test.h的内容//main.cpp的内容静态成员函数当一个类里有静态数据成员时，一般会定义相应的访问该静态数据成员的静态成员函数静态成员函数当一个类里有静态数据成员时，一般会定义相应的访问静态成员静态数据成员对于非静态数据成员，类的每个对象都拥有自己的拷贝，而对于静态数据成员，整个类只有一个拷贝，该拷贝为类的所有对象共享。静态数据成员的唯一性：独立于类的任何对象而存在的惟一实例静态成员函数静态成员函数没有this指针，静态成员函数只能访问静态数据成员。当一个类有静态数据成员时，一般会定义相应的访问该静态数据成员的静态成员函数静态成员静态数据成员静态成员为一个类设置一个计数器，用以记录当前已经存在的该类的对象个数。静态成员为一个类设置一个计数器，用以记录当前已经存在的该类的静态成员classM{ inta; staticintcount;public: M(intx):a(x) {++count;} M(constM&m):a(m.a) {++count;} ~M(){--count;} staticintGetCount()

{returncount;

}};intM::count=0;intmain(){Mm1(1),m2(m1);M*m3=newM(3);cout<<M::GetCount();deletem3;cout<<M::GetCount();return0;}静态成员intM::count=0;静态成员单件模式意图：保证一个类仅有一个实例，并提供一个访问该实例的全局访问点。《设计模式——可复用面向对象软件的基础》静态成员单件模式《设计模式——可复用面向对象软件的基础》静态成员classM{ inta;public: M(intx):a(x) {}};intmain(){Mm1(1),m2(2);return0;}classM{

inta; M(intx):a(x) {}public:};M*M::p=0;staticM*p;staticM*GetInstance(){if(p==0){p=newM(3);}returnp;}M*s1=M::GetInstance();M*s2=M::GetInstance();return0;静态成员classMintmain()classMM*3.3调用构造函数和析构函数的顺序3.3调用构造函数和析构函数的顺序调用构造函数和析构函数的顺序在一般情况下，调用析构函数的次序与调用构造函数的次序恰好相反：最先调用构造函数的对象，最后调用析构函数。而最后调用构造函数的对象，最先调用析构函数。可简记为：先构造的后析构，后构造的先析构，它相当一个栈，后进先出。调用构造函数和析构函数的顺序在一般情况下，调用析构函数的次classPoint{intm_nX;intm_nY;public:Point(intx,inty):m_nX(x),m_nY(y){cout<<"con"<<endl;}voidSetXY(inta,intb){m_nX=a;m_nY=b;}voidPrintXY(){cout<<m_nX<<","<<m_nY;}~Point()

{cout<<"destroy"<<m_nX<<","<<m_nY<<endl;}};intmain(){Pointp1(10,20);Pointp2(13,15);

p1.SetXY(20,10);p2.PrintXY();return0;}intmain()3.4对象数组3.4对象数组对象数组可以定义对象的数组。定义一个长度为n的对象数组会创建n个对象，这n个对象占据连续的存储空间。定义一个长度为n的对象数组会调用n次构造函数。对象数组的使用方式和普通数组一样。对象数组可以定义对象的数组。classPoint{ intm_nX;intm_nY;public: Point():m_nX(0),m_nY(0) {} Point(intx,inty=0):m_nX(x),m_nY(y) {}};Pointa1[5];Pointa2[2]={Point(10,20),Point(30,40)

};Pointa2[3]={Point(10,20)};Pointa2[3]={Point(10),Point(30),Point(40)};Point*p=newPoint[4];//创建5个对象，调用5次默认构造函数classPoint//创建5个对象，调用5次默认构造函数3.5对象与指针3.5对象与指针对象与指针创建一对象后，对象要占据一定的存储空间，所以对象也有地址，对象的地址就是对象所占据存储空间的首地址。可以定义指针变量来存储对象的地址。对象与指针创建一对象后，对象要占据一定的存储空间，所以对象也对象与指针classPoint{ intm_nX;intm_nY;public: Point(intx,inty) :m_nX(x),m_nY(y) {}

voidPrintXY()const {cout<<m_nX<<","<<m_nY<<endl;}

voidSetXY(intx,inty)

{m_nX=x;m_nY=y;}};对象与指针classPoint对象与指针intmain(){ Pointp(10,20); p.PrintXY(); Point*ptr=&p; ptr->PrinXY(); return0; }对象与指针intmain()对象与指针可以用new运算符在堆空间中创建对象intmain(){ Pointp(10,20); p.PrintXY(); Point*ptr=newPoint(20,40); ptr->PrinXY(); deleteptr; return0; }Point*ptr=newPoint;//编译错误对象与指针可以用new运算符在堆空间中创建对象Point*对象与指针可以让对象的地址作为函数的参数voidf(Point*p){ p->SetXY(10,10);}intmain(){ Pointp1(20,20); f(&p1); p1.PrintXY(); return0;}对象与指针可以让对象的地址作为函数的参数对象与指针this指针每个非static成员函数都被包含一个this指针，指向调用这个成员函数的对象。classX{ inta;public: voidset(intb){a=b;}};Xx1;x1.set(3);Xx2;x2.set(4);{this->a=b;}对象与指针this指针{this->a=b;}对象与指针双向链表classNode{ intvalue; Node*pre; Node*suc;public: voidappend(Node*p) {p->suc=suc; p->pre=this; suc->pre=p; suc=p;}};^476^9p1p2p2->append(p1);对象与指针双向链表^476^9p1p2p2->append(3.6const对象与const成员3.6const对象与const成员const修饰符的用法格式1：修饰普通常量const类型常量名=值;constdoublePI=3.1415;格式2：修饰引用const类型&引用名=变量名;说明：不能通过常引用修改所引用的对象。inti=0; constint&refi=i; i++;//

OK refi++;//Error!const修饰符的用法格式1：修饰普通常量const修饰符的用法格式3：

修饰指针变量，放在类型前面const类型*指针变量;inta=6,b=7;constint*p=&a //表示不能通过p改变p指向的内存的内容*p=19a=19; p=&b;

//错误//正确//正确const修饰符的用法格式3：修饰指针变量，放在类型前面/const修饰符的用法格式4：

修饰指针变量，放在指针变量前面类型*const指针变量;inta=6,b=7;int*constp=&a //表明指针变量p是一常变量*p=19a=19; p=&b;

//正确//正确//错误const修饰符的用法格式4：修饰指针变量，放在指针变量前const修饰符的用法const修饰函数中的参数 voidfun(constint&x)；表示形参x的值在fun函数中不能被修改voidfun(constint*x)；表示不能通过形参x改变x指向的内容。const修饰符的用法const修饰函数中的参数const修饰符的用法voidfun(int&x){ ++x;}intmain(){ ints=100; fun(s); cout<<s; return0;}voidfun(constint&x)//错误const修饰符的用法voidfun(int&x)vconst修饰符的用法voidfun(int*x){ ++x; *x=4;}intmain(){ inta[3]={1,3,5}; fun(a

); return0;}voidfun(constint*x)//错误const修饰符的用法voidfun(int*x)vconst修饰符的用法当引用作为函数的形参时，如果在函数体里面没有修改形参，最好在形参前面加const修饰。当指针作为函数的形参时，如果在函数体里面没有修改指针指向的内容，最好在形参前面加const修饰。voidprint(int*a,intn){ for(inti=0;i<n;++i) {cout<<a[i];}}constconst修饰符的用法当引用作为函数的形参时，如果在函数体里在类中使用const修饰符const成员函数（只读成员函数）const成员函数不能