c++程序设计基础.pptx

《c++程序设计基础.pptx》由会员分享，可在线阅读，更多相关《c++程序设计基础.pptx（99页珍藏版）》请在课桌文档上搜索。

1、第十一章 程序设计基础,问题的提出,结构化程序设计方法将解决问题的重点放在如何实现过程的细节方面，而把数据和对数据进行操作的函数截然分开，以数据结构为核心，围绕着功能实现或操作流程来设计程序。程序的基本形式是主模块与若干子模块的组合，即一个主函数（main 函数）和若干子函数。程序以函数为单位，函数之间以数据作为连接的纽带。把数据和操作分开对待，一旦数据的格式或结构发生变化，相应的操作函数就得改写，而且对于核心数据的访问往往也得不到有效控制。,教学目标,理解面向对象的概念，理解面向对象程序设计的思想，理解面向对象程序设计的基本方法。理解抽象、封装、继承、多态等概念。理解类与对象的概念，掌握程序

2、设计中类与对象的定义方法。理解基类、派生类概念、了解派生类的定义方法。理解多态性与虚拟函数的概念，了解虚拟函数的定义方法。,1.函数的重载,函数的重载：一个函数可以对应多个函数的实现，可以实现不同的功能重载函数：具有相同的名称，具有不同的参数个数或参数类型,【例】用重载函数求两个整数或实数中的最大数,#include int max(int a,int b)if(ab)return a;else return b;float max(float a,float b)if(ab)return a;else return b;,void main()int a,b;float x,y;cinab;

3、cinxy;coutmax(a,b)=max(a,b)endl;coutmax(x,y)=max(x,y)endl;,#include double max(double a,double b)if(ab)return a;else return b;,void main()int x,y;cinxy;coutmax(x,y)=max(x,y)endl;,float max(float a,float b)if(ab)return a;else return b;,能否得出正确的运行结果？,2.带默认参数的函数,允许实参和形参个数不同在形参表中各一个或几个形参指定默认值若没有给指定默认值的形参

4、传值，函数自动使用形参的默认值,【例】设计一个函数，既可以找出两个整型数的最大值，又可以找出三个数的最大值,#include int max(int x,int y,int z=-32768)if(yx)x=y;if(zx)x=z;return x;main()int a,b,c;coutabc;if(c-32768)coutmax(a,b,c)=max(a,b,c)endl;elsecoutmax(a,b)=max(a,b)endl;,赋予默认的参数必须放在形参表的最右端,注意：不要同时使用带默认参数的函数和重载函数(参数个数不同),3.C+新增运算符,作用域运算符,:指定变量的作用域，可以

5、访问当前作用于之外的变量,#includeint x=20;/全局变量void main()float x=8.9;/局部变量coutx=xendl;/输出局部变量,cout“x=”:xendl;/输出全局变量,动态内存分配与撤销运算符,new自动为变量分配正确长度的内存空间分配成功则返回指定类型的一个指针若不成功则返回0格式：new 类型 初值,int*p;p=new int(10);/为指针分配10个字节的内存单元,int*p;p=new int10;/为指针分配10个整型元素内存单元,Delete必须用于先前用new分配的有效指针格式：delete 指针变量；,#include void

6、 main()int*p;p=new int10;/为指针p分配10个元素的整型数组/的内存单元if(!p)/判断返回的是否为空指针cout内存分配失败endl;for(int i=0;i10;i+)pi=i;/为p所指内存单元赋值coutpi;/输出p所指内存单元的值delete p;/释放为指针p分配的内存单元,4.类和对象,类的定义,将不同类型的数据和对这些数据相关的操作封装在一起,class 类名 private:私有成员数据及函数;protected:保护成员数据及函数;public:公有成员数据及函数;,只能被本身的成员函数调用，外界不能调用,只能被本身的成员函数调用，可以被继承,

7、类与外部的接口，任何外部函数都可以访问公有数据或函数,class Employee private:/私有成员数据 char EmployeeID20;char EmployeeName50;char sex;public:/公有成员数据及函数;Employee();void display();,类定义只说明产生了一种新的数据类型，并没有为该类数据分配内存空间。,对象的定义,两种方式定义对象：,1先定义类再定义变量,class Employee private:/私有成员数据 char EmployeeID20;char EmployeeName50;char sex;public:Empl

8、oyee();/公有成员数据及函数;void display();Employee ep1,ep2;,2定义类的同时定义变量,class Employee private:/私有成员数据 char EmployeeID20;char EmployeeName50;char sex;public:Employee();/公有成员数据及函数;void display();ep1,ep2;,成员函数的定义,只有类的成员函数才能存取该类对象的私有数据成员,class rect_area private:/私有成员数据 float len;float width;float area;public:/公

9、有成员数据及函数;void area()area=len*width;cout“area=”areaendl;rect_area rectangle;,方法的实现(成员函数的函数体)可以在类的内部完成(类的内联函数),也可以在类的外部实现，而且可以与类的定义放在同一个源文件中，也可放在不同的源文件中。,class rect_area private:/私有成员数据 float len;float width;float area;public:/公有成员数据及函数;void area(float len,float width)；;rect_area rectangle;,若成员函数的实现在类

10、定义的外部，则定义是必须在函数名前加上类名，中间用“:”隔开,void rect_area:area(float len,float width)area=len*width;cout“area=”areaendl;,一般将类的定义放在.h的文件中，而把成员函数的实现放在一个与.h文件同名的.cpp文件中,类的成员数据可以是任意类型，但不能对成员数据初始化,class rect_area private:/私有成员数据 float len=10;float width=20;float area;public:/公有成员数据及函数;void area()area=len*width;cout“

11、area=”areaendl;rect_area rectangle;,类的私有成员,只有类本身的成员函数或其友元函数可以使用。,#include class rect_area private:float len;float width;float area;public:void qarea()area=len*width;coutarea=areaendl;rectangle;,void main()rectangle.len=10;rectangle.width=20;rectangle.qarea();,public:,类的公有成员,可以被类本身的成员函数和外部函数可以使用。,#in

12、clude class rect_area private:float area;public:void qarea(float len,float width)area=len*width;coutarea=areaendl;rectangle;,void main()rectangle.qarea(10,20);,内联函数,在类内部定义的成员函数。可提高程序的运行速度，在调用处用内联函数体的代码替换，不需要进行现场处理，节省了时间和空间开销。,#include class rect_area private:float area;public:void qarea(float len,fl

13、oat width)area=len*width;coutarea=areaendl;rectangle;,#include class rect_area private:float area;public:void qarea(float len,float width)；rectangle;,void rect_area:qarea(float len,float width)area=len*width;coutarea=areaendl;,inline,内联函数一定在调用前定义，且不允许有循环语句和开关语句，无法递归调用。,void main()rectangle.qarea(10,

14、20);,构造函数,类体中不允许对数据成员进行初始化用构造函数来初始化对象的数据成员，使对象在被使用之前处于一个合理的状态。,为什么要用构造函数？,class classnamepublic:classname();/构造函数;,一般声明为public构造函数的名字必须与所在的类名相同没有返回值，也不需要加void类型声明在定义类的对象时，由系统自动调用该类的构造函数，而且只能调用一次。,若在类定义时没有定义任何构造函数，由系统自动生成一个不带参数的默认构造函数 classname:classname()在程序中定义一个对象没有指明初始化，则编译器按默认的构造函数来初始化对象，对象的所有数据初

15、始化为0或空。,#include class rect_area private:/声明下面部分为私有数据成员 float area;float len;float width;public:rect_area()/构造函数 len=10;width=20;area=len*width;coutarea=areaendl;,void main()rect_area qarea;,#include class rect_area private:/声明下面部分为私有数据成员 float area;float len;float width;public:rect_area(float len=1

16、0,float width=20)/构造函数可以有默认参数 area=len*width;coutarea=areaendl;,void main()rect_area qarea;,构造函数在定义对象的同时调用，如果要通过实参给构造函数传递数据，可以采用如下形式来定义对象。类名 对象名(实参表)；,void main()rect_area qarea;rect_area qarea1(30,20);rect_area qarea2(20,20);,构造函数可以有默认参数，默认参数可以改变,#include class rect_area private:/声明下面部分为私有数据成员 floa

17、t area;float len;float width;public:rect_area()/构造函数 area=10*20;coutarea=areaendl;,rect_area:rect_area(float len=10,float width=20)area=len+width;coutarea=areaendl;,void main()rect_area qarea1(30,20);rect_area qarea2;,无法确定调用哪个构造函数,有默认参数的函数和没有参数的函数重载时，可能产生二义性,析构函数,用于回收构造函数动态申请的存储空间构造函数的名字必须与所在的类名相同，前

18、面加没有返回值，也不需要加void类型声明不允许带参数，且不能重载，一个类只有一个析构函数,class classnamepublic:classname();/析构函数;,若在类定义时没有定义任何析构函数，由系统自动生成一个不带参数的默认构造函数 classname:classname()函数中定义对象后，这个对象的生存期从开始定义到函数结束，此时自动运行解析函数；用new运算符创建的对象用delete运算符释放时，系统自动运行解析函数。,#include#include class stud char*name;int ave;public:stud(char*str,int k)/定义构

19、造函数int len;len=strlen(str)+1;name=new charlen;strcpy(name,str);ave=k;,stud()/析构函数 delete name;coutname is delected!endl;void display()/成员函数coutnames ave is aveendl;,void main()stud student(Liu Lin,86);student.display();,#include#include class stud/类定义 char*name;int ave;public:stud(char*str,int k);st

20、ud();void display();,stud:stud(char*str,int k)/在类定义之外定义构造函数int len;len=strlen(str)+1;name=new charlen;strcpy(name,str);ave=k;,stud:stud()/在类定义之外定义析构函数delete name;coutname is delected!endl;,void stud:display()coutnames ave is aveendl;,void main()stud student(Liu Lin,86);student.display();,类的友元,友元函数或友

21、元类的成员函数可以访问类的私有成员,友元函数,在类中声明，在类外定义声明时在函数类型前加上friend可将其他类的成员函数或非成员函数声明为该类的“友元”,#include class frect_area private:/声明下面部分为私有数据成员 float area;float len;float width;public:frect_area(float x,float y)len=x;width=y;friend void rect_area(frect_area class_sub);/声明函数rect_area为类frect_area的友元;,void rect_area(fr

22、ect_area class_sub)/友元函数的定义 class_sub.area=class_sub.len*class_sub.width;/通过友元函数访问类的私有成员 coutarea=class_sub.areaendl;void main()frect_area prect(5,2);rect_area(prect);,定义与普通函数定义基本相同，而与成员函数的定义不同，前面不需要加类名和作用域运算符:,友元类,若A是B的友元类，则A的所有成员函数都是B 的友元函数，都可以访问B的私有成员和保护成员。,class Bfriend class A;/声明A是B的友元类;,友元类不一

23、定是相互的,#include class A private:/声明下面部分为私有数据成员 float area;float len;float width;public:A(float x,float y)len=x;width=y;friend class B;/将B类定义为A类的友元类;,class B/B类的成员函数可以直接引用A类的私有数据成员 public:void rect_area(A a)a.area=a.len*a.width;coutarea=a.areaendl;void main()A prect(5,2);B b;b.rect_area(prect);,友元类必须在

24、它被定义之前声明，因此A在B前类的友元可以在public部分，也可在private部分,this指针,指向一个类对象，是C+自动生成的一个隐含指针隐含于每个类的成员函数之中，成员函数访问类成员变量的格式可以写成：,this-成员变量,当对象调用成员函数时，该成员函数的this指针便指向这个对象不能用this指针调用类的友元函数，因为友元函数不是类的成员，也不能用this指针指向类的静态成员。,#include class A int i;public:/公有部分A(int j=0)this-i=j;/this指针的应用A add(int k)this-i*=k;return*this;void

25、 disp()/用于输出的成员函数coutiendl;coutthe value of this pointer isthisendl;,void main()A a1(5);a1.disp();A a2=a1.add(5);a2.disp();,5.重载,成员函数重载,函数名相同，但参数个数或类型不同,#include class max_classpublic:int max(int a,int b);/重载函数float max(float a,float b);,int max_class:max(int a,int b)/类的重载函数的定义if(ab)return a;elseret

26、urn b;,float max_class:max(float a,float b)/类的重载函数的定义if(ab)return a;elsereturn b;,void main()max_class outmax;int x,y;float a,b;coutxy;/输入x,ycoutab;/输入a,bcoutmax(x,y)=outmax.max(x,y)endl;/输出结果 coutmax(a,b)=outmax.max(a,b)endl;,构造函数重载,#include class max_classpublic:max_class(int a,int b,int c);/定义重载的

27、构造函数max_class(float a,float b);,max_class:max_class(int a,int b,int c)/定义构造函数max_class(int a,int b,int c)if(ba)a=b;if(ca)a=c;coutmax(a,b,c)=aendl;,max_class:max_class(float a,float b)/定义构造函数(float a,float b)if(ab)coutmax(a,b)=aendl;elsecoutmax(a,b)=bendl;,void main()max_class A(9,5,8);/声明对象max_class

28、 B(5.6,9.3);,系统根据不同的参数分别调用不同的构造函数,1.重载为类的成员函数,在类内定义运算符重载函数的格式为：operator(),以 operator 为关键字，编译器可以很容易将运算符重载函数与其他成员函数区别开来。,运算符重载的两种方式,在类外定义运算符重载函数的格式为：:operator(),class Complex float Real,Image;public:.Complex(float a=0,float b=0)Real=a;Image=b;Complex operator+(const Complex,【例】实现复数类的“+”，“-”等重载运算(运算符重载

29、.cpp),Complex Complex:operator+(const Complex,void main()Complex c1(2,3),c2(4,-2),c3;c3=c1+c2;c3=c1+5;c3=-c1;,编译器将 c1+c2 解释为：c1.operator+(c2),将 c1+5 解释为：c1.operator+(5),第1个运算量是对象，第2个运算量是参数。,将-c1 解释为：c1.operator(),当用成员函数实现运算符的重载时，重载函数的 参数个数只能是 0 个或 1 个。分别实现：一元、二元 运算符的重载。,2.重载为友元函数,class Complex float

30、 Real,Image;public:.friend Complex operator+(const Complex,在 main()函数中,若有 Complex c1,c2;则编译器将 c1+c2 解释为：operator+(c1,c2),将 c1 解释为：operator(c1),【例】用友元函数实现复数类的“+”和“”重载运算,当用友元函数实现运算符的重载时，重载函数的 参数个数只能是1 个或 2 个。分别实现：一元运算符重载、二元运算符重载,3.两种重载方式的比较,因此：对一般的二元运算符重载为友元函数比重载为成员函数更优越。但是对于赋值运算符，将其重载为成员函数较好，因为赋值运算符是

31、一个二元运算符，其语法格式为=，第一个运算量必须是对象（变量也是对象），通过对象调用成员函数比较自然。若重载为友元，则可能会出现5.6=c这样的表达式，与赋值表达式的语义不一致。,运算符重载,将C+语言中已有的运算符赋予新的功能，与运算符的本来含义不发生冲突，使用时根据运算符所在位置判断具体执行哪种运算。,两种：重载为类的成员函数或类的友元函数。,重载为类的成员函数,首先在定义时使用如下格式用声明,类型 operator 运算符(形参表)；,按如下格式定义重载运算符函数,返回值类型 类名:operator(形参表)；,#include#include class addclass/声明一个类i

32、nt num;public:addclass(int a=0)/构造函数 num=a;addclass operator+(addclass a);/声明重载的运算符+void disp();,addclass addclass:operator+(addclass A)/定义重载的运算符函数实现addclass B;B.num=num+A.num;return B;,void addclass:disp()coutz=numendl;,void main()addclass x(3),y(4),z;/声明addclass的3个对象z=x+y;/对象x调用重载运算符+与对象y相加，并将返回值赋

33、给zz.disp();,重载运算符作为类的成员函数时，处理的数据有一个来自对象本身，运算符重载的参数比正常运算符少1,重载为类的友元函数,更灵活，可以自由的访问任何数据成员，所需要的操作数都需要由形参来传递,#include#include class addclass/声明一个类int num;public:addclass(int a=0)/构造函数num=a;friend addclass operator+(addclass a,addclass b);/运算符+重载友元函数void disp();,addclass operator+(addclass A,addclass B)/定

34、义运算符重载友元函数实现return(B.num+A.num);void addclass:disp()coutz=numendl;,void main()addclass x(3),y(4),z;z=x+y;/使用重载运算符z.disp();,class Student int num;char name30;char sex;public:void display()/对成员函数display的定义 coutnum:numendl;coutname:nameendl;coutsex:sexendl;,6.继承,class Studend1 int num;/此行原来己有 char name

35、20;/此行原来己有 char sex;/此行原来己有 int age;char addr20;public:void display();/此行原来己有 coutnum:numendl;/此行原来己有 coutname:nameendl;/此行原来己有 coutsex:sexendl;/此行原来己有 coutage:ageendl;coutaddress:addrendl;,利用原来定义的类Student作为基础，再加上新的内容即可，以减少重复的工作量。C+提供的继承机制就是为了解决这个问题。,在C+中所谓“继承”就是在一个已存在的类的基础上建立一个新的类。已存在的类称为“基类(base c

36、lass)”或“父类(father class)”。新建立的类称为“派生类(derived class)”或“子类(son class)”。,class Student1:public Student/声明基类是Studentprivate:int age;/新增加的数据成员 string addr;/新增加的数据成员public:void display_1()/新增加的成员函数 coutage:ageendl;coutaddress:addrendl;,类A派生类B：类A为基类，类B为派生类。,A,B,新增加的成员数据和成员函数,基类与派生类,被继承的类叫基类(baseclass)或父类，

37、继承后产生的类叫派生类(derivedclass)或子类拥有自己的新数据和成员函数，还可以拥有父类的数据成员和成员函数。任何类都可以成为基类，一个基类可以有多个派生类，一个派生类还可以成为其他类的基类。,class 派生类名:继承方式基类名派生类新增的数据成员；派生类新增的成员函数；,规定如访问基类的成员，可以有private,public,protected,class personprivate:char name10;char sex3;int age;public:void init(char*str1,char*str2,int k)/定义初始化成员函数 strcpy(name,st

38、r1);strcpy(sex,str2);age=k;void disp()/定义输出成员函数 coutname:nameendl;coutsex:sexendl;coutage:ageendl;,class student:public person/派生类的定义private:char sclass11;int num;float avg;public:void init_stud(char*str,int i,float j)strcpy(sclass,str);num=i;avg=j;void disp_stud()coutclass:sclassendl;coutnum:numend

39、l;coutavg:avgendl;,公有派生class ClassName:public BaseClassName公有派生时，基类中所有成员在派生类中保持各个成员的访问权限。,公有派生，派生类中保持基类的成员特性,基类：public:在派生类和类外可以使用protected:在派生类中使用private:不能在派生类中使用,class A int x;protected:int y;public:int z;A(int a,int b,int c)x=a;y=b;z=c;/基类初始化 int Getx()return x;/返回x int Gety()return y;/返回y void

40、ShowA()cout x=xty=ytz=zn;class B:public Aint m,n;public:B(int a,int b,int c,int d,int e):A(a,b,c)m=d;n=e;void Show()cout“m=mt“n=nn;coutx=Getx()ty=ytz=zn;int Sum()return(Getx()+y+z+m+n);void main(void)B b1(1,2,3,4,5);b1.ShowA();b1.Show();cout Sum=b1.Sum()n;coutx=b1.Getx()t;cout y=b1.Gety()t;cout z=b1

41、.zn;,公有派生,对基类初始化,因为x是基类私有，所以在派生类和类外不能直接引用,因为y是基类保护，所以在派生类中可以直接引用。而在类外不可直接引用。,因为z是基类公有，所以在派生类中和类外均可直接引用。,私有派生class ClassName:private BaseClassName私有派生时，基类中公有成员和保护成员在派生类中均变为私有的，在派生类中仍可直接使用这些成员，基类中的私有成员，在派生类中不可直接使用。,私有派生，派生类中基类公有和保护成员成为私有,基类：public:(变为私有)在派生类中使用，类外不可使用protected:(变为私有）在派生类中使用，类外不可使用priv

42、ate:不能在派生类中和类外使用,class A int x;/私有继承.cppprotected:int y;public:int z;A(int a,int b,int c)x=a;y=b;z=c;/基类初始化 int Getx()return x;/返回x int Gety()return y;/返回y void ShowA()cout x=xty=ytz=zn;class B:private Aint m,n;public:B(int a,int b,int c,int d,int e):A(a,b,c)m=d;n=e;void Show()cout“m=mt“n=nn;coutx=G

43、etx()ty=ytz=zn;/ShowA();int Sum()return(Getx()+y+z+m+n);void main(void)B b1(1,2,3,4,5);b1.ShowA();b1.Show();cout Sum=b1.Sum()n;coutx=b1.Getx()t;cout y=b1.Gety()t;cout z=b1.zn;,私有派生,对基类初始化,因为x是基类私有，所以在派生类和类外不能直接引用,y是基类保护，所以在派生类中可以直接引用。而在类外不可直接引用。,保护派生class ClassName:protected BaseClassName保护派生时，基类中公有

44、成员和保护成员在派生类中均变为保护的和私有的，在派生类中仍可直接使用这些成员，基类中的私有成员，在派生类中不可直接使用。,保护派生，派生类中基类公有和保护成员降级使用,基类：public:(变为保护)在派生类中使用，类外不可使用protected:(变为私有）在派生类中使用，类外不可使用private:不能在派生类中和类外使用,多重继承,A,B,C,多重继承是单一继承的扩展,派生类中新定义的成员,可以用多个基类来派生一个类。,格式为：class 类名:类名1,.,类名n private:.；/私有成员说明;public:.；/公有成员说明;protected:.；/保护的成员说明;,继承方式,

45、class D:public A,protected B,private C./派生类中新增加成员;,class Aint x1,y1;public:A(int a,int b)x1=a;y1=b;void ShowA(void)coutA.x=x1tA.y=y1endl;class Bint x2,y2;public:B(int a,int b)x2=a;y2=b;void ShowB(void)coutB.x=x2tB.y=y2endl;class C:public A,private Bint x,y;public:C(int a,int b,int c,int d,int e,int

46、f):A(a,b),B(c,d)x=e;y=f;void ShowC(void)coutC.x=xtC.y=yendl;ShowA();ShowB();void main(void)C c(1,2,3,4,5,6);c.ShowC();c.ShowA();c.ShowB();,公有派生,私有派生,仍为公有,成为私有,非法，私有成员类外不可调用,B b1(10,20);b1.ShowB();,初始化基类成员,构造函数不能被继承,派生类的构造函数必须调用基类的构造函数来初始化基类成员基类子对象。,派生类构造函数的调用顺序如下：基类的构造函数子对象类的构造函数派生类的构造函数,class B:pub

47、lic A int y;A a1;public:B(int a,int b):A(a),a1(3)y=b;.;,当撤销派生类对象时，析构函数的调用正好相反。,基类的构造函数子对象类的构造函数派生类的构造函数,【举例】有三个基类Base1、Base2和Base3。Base1、Base2的构造函数带有参数，Base3有一个不带参数的构造函数。类Derive由这三个基类经过公有派生而来。Derive新增加了三个私有对象成员memberBase1、memberBase2和memberBase3，它们分别是Base1、Base2和Base3类的对象。派生类没有定义（即采用默认的）析构函数。程序代码如下：

48、,/派生构造.cpp:演示继承与派生的构造函数和析构函数#include class Base1/基类Base1，构造函数有参数 public:Base1(int i)coutconstructing Base1 iendl;Base1()coutdestructing Base1endl;,class Base2/基类Base2，构造函数有参数 public:Base2(int j)coutconstructing Base2 jendl;Base2()coutdestructing Base2endl;,class Base3/基类Base3，构造函数无参数 public:Base3()c

49、outconstructing Base3endl;Base3()coutdestructing Base3endl;,/派生新类:class Derive:public Base2,public Base1,public Base3 private:/派生类新增私有对象成员 Base1 memberBase1;Base2 memberBase2;Base3 memberBase3;public:/派生类的构造函数 Derive(int a,int b,int c,int d):Base1(a),memberBase2(d),memberBase1(c),Base2(b);void main(

50、)Derive object(2,4,6,8);,列出所有需要使用参数进行初始化的基类名字和所有对象成员的名字及各自的参数列表，对于使用默认构造函数的基类或对象成员，可以不给出类名或对象名及参数,程序运行结果为：constructing Base2 4constructing Base1 2constructing Base3 constructing Base1 6constructing Base2 8constructing Base3 destructing Base3destructing Base2destructing Base1destructing Base3destruct