C++要点、重点复习

C++面向对象程序设计复习2015-1-12第1章复习要点简单的C++程序#include<iostream>//用cout输出时需要用

//此头文件usingnamespacestd;//使用命名空间stdintmain(){cout<<"ThisisaC++program.\n";//用C++的方法输出一行

return0;}输入和输出

格式：cout<<cin>> endl表示结束一行 数据类型const常量定义

constfloatPI=3.14159；

占用存储单元，只读不可写函数原型声明

格式：函数类型函数名(参数列表);intmax(intx,inty);

要求：函数调用之前必须对所调用的函数作函数原型声明函数重载 定义〔overload〕 要求：参数个数或参数类型不同有默认参数的函数 格式：floatarea(floatr=6.5) 与函数重载的关系函数模版、函数重载例题1、对重载函数形参的描述中，错误的选项是

A.参数的个数可能不同

B.参数的类型可能不同

C.参数的顺序可能不同

D.参数的个数、类型、顺序都相同，只是函数的返回值类型不同

D变量的引用* 函数传值与函数传地址 比照引用与指针：P19例1.10&1.11内置函数 inline 作用：空间换时间作用域运算符::字符串变量 string定义，与字符数组的关系 赋值 字符串操作：复制、连接、比较new和delete运算符例题1、对于动态分配内存空间描述正确的选项是

A．使用new运算符分配的内存空间的长度必需是常量

B．delete运算符可以释放动态的存储空间和静态的存储空间

C．由new分配的内存空间是不连续的

D．delete运算符只能释放由new分配的动态存储空间D什么是蓝？类与对象类和对象在C++中，类是一种数据类型。intx;classstudentstd1;根本数据类型用户定义数据类型变量〔实例〕对象〔实例〕1.类的声明与对象的定义2.类的数据成员与成员函数3.对象成员的访问4.构造函数与析构函数5.Const6.Static7.New与delete8.拷贝构造函数9.友元第2章要点复习根本概念 对象 封装与信息隐蔽 抽象 继承与重用 多态性声明类类型*class

CGoods{

private

:

charName[21];

intAmount;

floatPrice;

floatTotal_value;public:void

CountTotal(void);};1.class关键字2.类名3.类体{};格式4.类数据成员5.类成员函数6.访问限定符定义对象的方法

1.先声明类类型，然后再定义对象

classStudentstud1；

Studentstud1；

2.在声明类类型的同时定义对象

classStudent{}stud1；

3.不出现类名，直接定义对象

class{}stud1；类与结构体类型的异同

1.用class声明的类如果不带成员访问限定符，所有成员默认限定为private；

2.用struct声明的类如果不带成员访问限定符，所有成员默认限定为public。类成员数据成员/成员变量--private成员函数/成员方法--publicinline成员函数成员函数的存储方式成员函数的存储方式数据区代码区对象1对象２数据区代码区对象ｎ．．．．．．数据区代码区数据区对象1数据区对象２数据区对象ｎ．．．．．．公共代码区对象成员的访问*对象名+成员运算符stud1.num=1001;对象指针Student*p=&stud1;pnum=1001;

对象引用Student&s=stud1;s.num=1001;类的封装性和信息隐蔽1.公用接口与私有实现的别离2.类声明和成员函数定义的别离P64-653.名词：对象、方法、消息stud.display();第3章复习要点构造函数*构造函数是特殊的公有成员函数，其特征如下： 1.函数名与类名相同。 2.构造函数无函数返回类型说明。注意是什么也不写，也不可写void！实际上构造函数有返回值，返回的就是构造函数所创立的对象。 3.在程序运行时，当新的对象被建立，该对象所属的类的构造函数自动被调用，在该对象生存期中也只调用这一次。 4.构造函数可以重载。严格地讲，说明中可以有多个构造函数，它们由不同的参数表区分，系统在自动调用时按一般函数重载的规那么选一个执行。 5.构造函数可以在类中定义，也可以在类外定义。 6.如果类说明中没有给出构造函数，那么C++编译器自动给出一个缺省的构造函数:类名(void){}但只要我们定义了一个构造函数，系统就不会自动生成缺省的构造函数。只要构造函数是无参的或各参数均有缺省值的，C++编译器都认为是缺省的构造函数，并且缺省的构造函数只能有一个。构造函数的重载*缺省构造函数

Time::Time() {hour=0;minute=0;sec=0;}Timet;带参数的构造函数

Time::Time(inth,intm,ints) {hour=h;minute=m;sec=s;}

Timet(13,10,11);用参数初始化表

Time::Time(inth,intm,ints):hour(h),minute(m),sec(s){}使用默认参数的构造函数

Time::Time(inth=13,intm=10,ints=11){hour=h;minute=m;sec=s;}Timet;析构函数 当一个对象定义时，C++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C++也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数〔destructor〕： 1.

构函数名与类名相同，但在前面加上字符‘~’，如~CGoods〔〕。 2.

析构函数无函数返回类型，与构造函数在这方面是一样的。但析构函数不带任何参数。 3.一个类有一个也只有一个析构函数，这与构造函数不同。析构函数可以缺省。 4.对象注销时，系统自动调用析构函数。调用构造函数和析构函数的顺序构造函数和析构函数例题1.在下面有关对构造函数的描述中，正确的选项是

。A.

构造函数可以带有返回值B.

构造函数的名字与类名完全相同C.

构造函数必须带有参数D.构造函数必须定义，不能缺省2．在下面有关析构函数特征的描述中，错误的选项是

。A.

一个类中只能定义一个析构函数B.

析构函数名与类名完全相同C.

析构函数不能指定返回类型D.

析构函数不能带有参数3．假定AB为一个类，那么执行“AB

a(4),b[3],*p[2];”语句时，自动调用该类构造函数的次数为

。3

B.4

C.6

D.94.对于任意一个类，析构函数的个数最多为(B)A.0B.1C.2D.3对象数组

对象数组的定义、初始化、建立数组的同时调用构造函数

P82例3.6对象指针*

1.指向对象的指针

2.指向对象成员的指针

2.1.指向对象数据成员的指针

2.2.指向对象成员函数的指针

3.this指针

P85例3.7this指针的作用共用数据的保护Const对内存的使用—只读不可写〔写在首次/初始化完成〕。常对象constTimet； 或：Timeconstt；常数据成员constinthour;常成员函数voidget_time()const;指向对象的常指针

Time*constp1=&t1;指向常对象的指针变量

constTime*p1=&t1;对象的常引用

constTime&t=t1;voidfun(constTime&t);{//不可改变t的值}对象的动态建立和释放new&deleteBox*pt; pt=newBox;deletept;静态成员Static由关键字static修饰说明的类成员，成为静态类成员〔staticclassmember〕。虽然使用static修饰说明，但与函数中的静态变量有明显差异。类的静态成员为其所有对象共享，不管有多少对象，静态成员只有一份存于公用内存中。静态数据成员 初始化〔只能在类体外进行初始化〕 既可以通过对象名引用，也可以通过类名来引用静态成员函数 静态成员函数没有this指针 静态成员函数访问静态数据成员，不访问非静态成员对象的赋值对象的复制拷贝构造函数类名对象2〔对象1〕Box::Box(constBox&b){height=b.height;width=b.width;length=b.length;}Static例题假定类AB中有一个公有属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为

〔1〕

。静态成员〔static〕属于__类__，而不属于__任何一个对象__，它被同一个类的所有对象共享。友元

友元函数：friendvoiddisplay(Time&);

友元成员函数：friendvoidTime::display(Date&);友元类

允许另一个类或函数访问你的类的东西。ClassA{Private：inti=0;Friendclassb//声明}ClassB{}Voidmain(){Aa1=newA();Bb1=newB();Intj=b1.i;\\可直接访问A类里的}如B是A的友元类，那么a对b完全开放包括private，也就是B可以访问A里任何东西友元例题13、关于友元函数

的描述中，错误的选项是

A.友元函数不是成员函数

B.友元函数只能访问类中私有成员

C.友元函数破坏隐藏性，尽量少用

D.友元函数说明在类体内，使用关键字friendB类模版〔不考〕第4章复习要点运算符重载的方法* 格式：函数类型operator运算符名称(形参表列){对运算符的重载处理} 复数+P122例4.2 运算符重载的规那么P124-126运算符重载的实现

1.类成员函数

2.友元函数

参数个数参数次序类成员函数参数个数=原操作数个数-1（后置++、--除外）左侧为类类型友元函数参数个数=原操作数个数，且至少应该有一个自定义类型的形参。随意双目运算符重载

P134例4.4单目运算符重载区别“前置和后置”重载流插入运算符和流提取运算符* 重点是格式:友元函数/普通函数

istream&

operator>>(istream&,自定义类&);ostream&

operator<<(ostream&,自定义类&);不同类型数据间的转换〔不考〕运算符重载例题假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的减法，并返回相减结果，那么该成员函数的声明语句为：()A、AB&operator-() B、ABoperator-(AB&a)C、operator-(ABa) D、ABoperator-(AB&a,AB&b)B

第5章复习要点面向对象程序设计有4个主要特点：

1.抽象

2.封装

3.继承

4.多态性青处于蓝，而胜于蓝继承〔inheritance〕机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的根底上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构。表达了由简单到复杂的认识过程。多态性〔polymorphism〕多态性是考虑在不同层次的类中，以及在同一类中，同名的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性。以虚函数为根底的运行时的多态性是面向对象程序设计的标志性特征。表达了类推和比喻的思想方法。派生类的声明方式定义格式*class派生类名：访问限定符基类名1《，访问限定符基类名2，……，访问限定符基类名n》{《private:》

成员表1；》

//派生类增加或替代的私有成员《public:

成员表2；》

//派生类增加或替代的公有成员《protected:

成员表3；》

//派生类增加或替代的保护成员}；//分号不可少继承过程编制派生类时可分四步

吸收基类的成员

改造基类成员

开展新成员重写构造函数与析构函数

不管是数据成员，还是函数成员，除构造函数与析构函数外全盘接收声明一个和某基类成员同名的新成员,派生类中的新成员就屏蔽了基类同名成员称为同名覆盖〔override〕派生类新成员必须与基类成员不同名，它的参加保证派生类在功能上有所开展。派生类的构成*继承分类基类1基类2……基类n派生类1派生类2基类派生类1派生类2〔a〕多重继承〔b〕单继承一个基类可以直接派生出多个派生类

派生类可以由多个基类共同派生出来，称多重继承。派生类成员的访问属性*多级派生时的访问属性

P164例5.4继承例题1．在公有继承的情况下，基类成员在派生类中的访问权限

。A．受限制

B.保持不变

C.

受保护

D.

不受保护9.在公有派生情况下，有关派生类对象和基类对象的关系，不正确的表达是(A)A.派生类的对象可以赋给基类的对象B.派生类的对象可以初始化基类的引用C.派生类的对象可以直接访问基类中的成员D.派生类的对象的地址可以赋给指向基类的指针派生类的构造函数和析构函数*执行派生类构造函数的顺序是：

①调用基类构造函数，初始化基类数据成员 ②调用子对象构造函数，初始化子对象数据成员 ③执行派生类构造函数，初始化派生类数据成员执行派生类析构函数的顺序是：

①调用派生类析构函数，清理派生类增加数据成员 ②调用子对象析构函数，清理子对象数据成员 ③调用基类析造函数，清理基类数据成员构造函数和析构函数次序例题#include<iostream>usingnamecpacestd;classB1 //基类B1声明{public:B1(inti){cout<<"constructingB1"<<i<<endl;}~B1(){cout<<"destructingB1"<<endl;}};classB2 //基类B2声明{public:B2(intj){cout<<"constructingB2"<<j<<endl;} ~B2(){cout<<"destructingB2"<<endl;} };classB3 //基类B3声明{public:B3(){cout<<"constructingB3*"<<endl;}~B3(){cout<<"destructingB3"<<endl;} };classC:publicB2,publicB1,publicB3 {public: C(inta,intb,intc,intd):B1(a),memberB2(d),memberB1(c),B2(b){}private: B1memberB1; B2memberB2; B3memberB3;};voidmain(){ Cobj(1,2,3,4);}constructingB22constructingB11constructingB3*constructingB13constructingB24constructingB3*destructingB3destructingB2destructingB1destructingB3destructingB1destructingB2派生类构造函数一般形式：派生类名::派生类名(总参数表):

基类名(实参表),

子对象名(参数表){

派生类新增成员的初始化语句; }多层派生时的构造函数

P172例5.7派生类的析构函数与构造函数一样，不能继承基类的。派生类例题类A与类B都有public数据成员f,类C公有继承A和B,类C有public数据成员f，类D保护继承C,d是类D的一个对象，从d访问类A的成员f的表达式是

。d.A::f

多重继承定义：

classD:publicA,privateB,protectedC{类D新增加的成员}多重继承派生类的构造函数派生类构造函数名(总参数表)：基类1构造函数(参数表),基类2构造函数(参数表),基类3构造函数(参数表){派生类新增成员初始化语句}P176例5.8多重继承的二义性在多重继承时，基类与派生类之间，或基类之间出现同名成员时，将出现访问时的二义性〔不确定性〕——采用同名隐藏规那么或虚函数〔仅针对成员函数〕来解决。当派生类从多个基类派生，而这些基类又从同一个基类派生，那么在访问此共同基类中的成员时，将产生二义性——采用虚基类来解决。inta;inta;inta;虚基类*

P185例5.9classA{……};classB:virtualpublicA{……};classC:virtualpublicA{……};基类与派生类转换*大材小用第6章复习要点一个接口，多种方法多态性的概念静态多态在编译程序时系统就可以确定调用哪个函数，因此静态多态性又称编译时的多态性。静态多态性是通过函数重载实现的。动态多态在程序运行中才能确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过基类与派生类转换+虚函数实现的。多态性例题C++语言中的多态性分为

时多态性和运行时的多态性。编译

虚函数*虚函数是一个类的成员函数，定义格式如下：virtual返回类型函数名〔参数表〕；关键字virtual指明该成员函数为虚函数。virtual仅用于类定义中，如虚函数在类外定义，不可加virtual。当某一个类的一个类成员函数被定义为虚函数，那么由该类派生出来的所有派生类中，该函数始终保持虚函数的特征。当在派生类中重新定义虚函数〔overridingavirtualfunction,亦译作超载或覆盖〕时，不必加关键字virtual。但重新定义时不仅要同名，而且它的参数表和返回类型全部与基类中的虚函数一样，否那么联编时出错。虚函数与改造类成员，同名覆盖〔override〕有关：如未加关键字virtual，那么是普通的派生类中的新成员函数覆盖基类同名成员函数〔当然参数表必须一样，否那么是重载〕，可称为同名覆盖函数，它不能实现运行时的多态性。比较有虚函数的override和无虚函数的override，访问成员#include<iostream.h>

classB0

{public:

voiddisplay()

{

cout<<"B0::display()"<<endl;

}

};

classB1:publicB0

{public:

voiddisplay()

{

cout<<"B1::display()"<<endl;

}

};

classD1:publicB1

{public:

voiddisplay()

{

cout<<"D1::display()"<<endl;

}

};

voidfun(B0*ptr)

{

ptr->display();}

voidmain()

{

B0b0;

B1b1;

D1d1;

B0*p;

p=&b0;

fun(p);

p=&b1;

fun(p);

p=&d1;

fun(p);

}

B0::display()

B0::display()

B0::display()

#include<iostream.h>

classB0

{public:

virtualvoiddisplay()

{

cout<<"B0::display()"<<endl;

}

};

classB1:publicB0

{public:

voiddisplay()

{

cout<<"B1::display()"<<endl;

}

};

classD1:publicB1

{public:

voiddisplay()

{

cout<<"D1::display()"<<endl;

}

};

voidfun(B0*ptr)

{

ptr->display();}

voidmain()

{

B0b0;

B1