基础知识C++期末复习资料

C++期末复习（知识点与习题） 第一章 基本的面向对象概念 1．C++语言是在C语言的基础上增加了类的概念，使之成为一种面向对象的语言，故C++可以视为C语言的超集。（25页） （1）面向对象程序中，一切都是围绕着（A）展开的 A、类 B、结构 C、数据类型 D、实现过程 2．何谓类，与对象的区别。（6页----10页） 类是具有相同或相似属性和行为的对象的集合；而每个对象称为其类的一个实例。对象有属性和方法，故类一般包括属性和方法。 （1）一个类一般包括（A、C）内容（选择两项） A、属性 B、关系 C、方法 D、消息 3．面向对象的三个基本特征：封装、继承、多态。（12页） 封装是让您有选择的隐藏类中的特性和方法的过程（用private修饰） 继承是允许通过重用现有的类创建新类（可重用性） 多态性使同一函数在不同的类上具有不同的行为。 （1）下面 D 项不能算是面向对象程序设计所具有的显著特点。 A、封装 B、继承 C、多态性 D、函数调用 （2）在C++中，封装是借助于 B 达到的。 A、引用 B、类 C、指针 D、函数 4．结构和类之间有何差异？（17页） 定义结构的关键字是struct，定义类的关键字是class；类和结构都属于用户自定义类型。默认情况下，类中的成员是私有的，然而，在默认情况下，结构中的成员是公有的。结构通常只包含数据成员，而类中既有数据成员，也有成员函数，由函数操作数据成员。 （1）下面说法正确的是：（选两项）A、B A、在结构中，所有元素在默认情况下都是公有的 B、在类中，所有元素在默认情况下都是私有的 C、无论在结构还是在类中，所有元素在默认情况下都是公有的 D、无论在结构还是在类中，所有元素在默认情况下都是私有的 （2）以下C++中结构的特性对类不适用的是（A） A、对象可以进行四则运算 B、对象可以用作数组元素 C、对象可以用作函数参数 D、对象之间可以相互赋值 （3）下面选项中哪一项不是结构和类的共同特征（B） A、对象可以用作数组元素 B、在缺省情况下，成员是私有的 C、对象之间可以相互赋值 D、可以说明指向对象的指针和引用 5．类的私有、公有和保护部分分别由private、public和protected三个关键字确定的。关键字private、public和protected确定类成员的访问权限。（19页） 公有部分：可以在任何地方访问 私有部分：只能由类的成员函数或友元函数访问 保护部分：可由类的成员函数或友元函数访问，也可由派生类的成员函数或友元函数访问。 在类中，无论是在公有部分、在私有部分还是在保护部分，类中声明的变量和函数均为类的成员。变量称为数据成员，函数称为成员函数。成员函数必须定义返回类型。 （1）在下列关键字中，用以说明类中公有成员的是（A）（选择一项） A、public B、private C、protected D、friend （2）以下不属于类的存取权限的是（D）（选择一项） A、public B、private C、protected D、friend （3）在类说明符中，被指定为私有的数据或函数可以被以下的哪项访问：（选一项）B A、程序中的任何函数 B、类中的成员函数 C、类中的公有成员函数 D、类中的私有成员函数 6．类中的成员函数，必须使用该类的对象访问（调用），通过点运算符或叫成员运算符(．)将对象和成员函数连接起来。例如：（22页） #include //包含头文件 class example //定义类 { private: int x; //私有的数据成员的定义 public: void display(int a) //公有的成员函数的定义 { x=a; //通过成员函数操作数据成员 cout< class example { private: int x; public: void display(); //只保留成员函数的声明 }; void example::display() //在类外实现成员函数 { x=100; cout< int a=10; //定义全局变量a void main() { int a=50; //定义局部变量a cout<）,如： Time *p; //已知Time是一个类 p=new Time; //声明p为指向Time类的对象的指针 p->setTime(2,30,50); //setTime是类Time的一个成员函数 … … delete p; 12．构造函数：（39页） 构造函数是一个特殊的成员函数，能够自动初始化对象。由于类中的数据成员不能在定义是直接初始化，只能通过成员函数进行赋初值。一般都用构造函数来完成。构造函数具有下面5个特点： （1）构造函数与类同名 （2）构造函数没有返回类型 （3）构造函数有系统自动调用（当创建该类的对象时） （4）构造函数可以有0个、1个、或多个参数 （5）构造函数可以被重载（一个类可以有多个参数不同的构造函数） 任何一个类都有构造函数，如果没有在类中显示的定义，系统会自动生成一个，该构造函数没有参数，称为默认的构造函数。（构造函数必须是公有的）。如： 有以下类的说明，请指出错误的地方：__。（B） class Csample { int a; (A) Csample(); (B) public: Csmaple(int val); (C) Csmaple(); (D) }; 13．析构函数：（41页） 析构函数是一个特殊的成员函数，是在销毁一个类的对象时由系统自动调用的函数。析构函数具有下面5个特点： （1）析构函数与类同名，名称前加一个~。 （2）析构函数没有返回类型。 （3）析构函数由系统自动调用（当销毁该类的对象时） （4）析构函数不能有任何参数 （5）析构函数不能被重载（一个类只能由一个析构函数） 任何一个类都有析构函数，如果没有在类中显示的定义，系统会自动生成一个。 （1）下面关于类的构造函数的说法正确的是（B） A、一个类只能有一个构造函数 B、不能有返回类型 C、可以为void 类型 D、不能使用缺省参数 （2）下面（B）选项不是对类的复制构造函数的声明形式 A、A::A(A&); B、A::A(const &); C、A::A(A); D、A::A(A&a); （3）下面（A）选项是对类的析构函数的正确定义 A、A::~A() B、void A::~A(参数) C、A::~A(参数) D、void A::~A() （4）下面有关构造函数的正确说法是（D） A、new运算符不调用构造函数 B、构造函数一定调用new 运算符 C、当生成新类的实例时，同时自动调用new和构造函数进行初始化 D、当用new运算符动态产生类的对象时，new运算符也自动调用构造函数 （5）有关析构函数的不正确说法是（C） A、析构函数在对象生存期结束时自动被调用 B、析构函数不得指定参数 C、析构函数可以指定返回类型 D、析构函数名与类名相同 （6）下面有关类的说法错误的是（C） A、一各类可以有多个构造函数，但只有一个析构函数 B、析构函数和构造函数都不能有返回类型 C、可以给析构函数指定参数 D、构造函数不可以直接调用 （7）有关构造函数说法错误的是：C A、构造函数的名称与类名相同并可以有多个构造函数 B、构造函数不能有返回值 C、构造函数不能使用初始化列表 D、构造函数初始化时为对象开辟一个内存 14．析构函数最常用的方法是回收已分配的内存，此内存是使用new 运算符为该类对象分配的。由于析构函数是在销毁对象时调用的，所以，如果该类中包含指针数据成员，并通过new运算符进行了动态内存分配，那么当销毁该类的对象时，应该将动态申请的内存空间释放，这个释放的动作可以放在析构函数中来完成。如：（42页） #include class example { int *ptr; public: A(int=0); ~A(); }; A::A(int=0) { ptr=new int(a); } A::~A() { delete ptr; } 15．const关键字：（43页） const关键字在C++中用来定义常量。它的值不能在运行程序时修改。Const有下面几种常用的用法： （1）定义一般常变量 const int num=10; num=100; //错误 num++; //错误 （2）定义一个指向常量的指针 int num=10,a=20; const int *p=# *p=30; //错误 p=&a; //正确 num=30; //正确 （3）指针常量 int num=10,a=20; int * const p=# *p=30; //正确 p=&a; //错误 num=30; //正确 （4）指向常量的指针常量 int num=10,a=20; const int * const p=# *p=30; //错误 p=&a; //错误 num=30; //正确 （5）在函数的参数列表中使用 void func(const int a) { a=10; //错误 } void func(const char *str) { str=”Hello”; //正确 *str=’a’; //错误 } （6）下列说明中 const char *ptr; ptr应该是__。（ A、C）（选择两项） A、指向字符常量的指针 B、指向字符的指针常量 C、指向字符串常量的指针 D、指向字符串的指针常量 （7）请指出下列程序片断中的错误。并解释错在何处：A、D int index=255; const int *ptr=&index; int *const ntptr=&index; *ptr=430; (A) *ntptr=4330; (B) int another=5; ptr=&another; (C) ntptr=&another; (D) ptr是一个指向整型常量的指针。使用index的值ptr，不能更改它指向的位置， nptr是指向一个整数的常量指针。不能使它指向另一个变量。 （8）请指出下列程序片断中的错误。并解释错在何处：A、B int alpha=100; const int * const alptr=α int another=250; *alptr=35; (A) *alptr=&another; (B) Alptr是一个常数指针，它指向一个整型常数。既不能使它指向另一个变量，也不能用它来更改所指变量的内容。 （9） 声明函数是常成员函数的

格式

pdf格式笔记格式下载页码格式下载公文格式下载简报格式下载

是（D） A、关键字const放在函数参数表之前 B、关键字const放在函数参数表之后 C、关键字const放在函数体之后 D、关键字const放在函数参数表之后、函数体之前 18．this指针（45页） 一个类中的任何一个成员函数中都有一个名为this的特殊的指针，this给出用于调用成员函数的对象的地址。每当调用成员函数时，编译器会向this指针分配调用该函数对象的地址。所以不需要对象名称就可以在成员函数中访问对象的成员。this指针可以显示的使用，也可以省略不写。如： #include class person { int age; public: person(); void display(); }; person::person() { age=25; } void person::display() { cout<age<来访问所有对象的成员 D、this指针指向当前对象的地址 19．对象和函数在内存中的存储方式（47页） 如果一个类有三个对象，那么将有三个数据成员的副本，但只有一个成员函数的副本。换句话说，每个对象都有其自己的类的数据成员副本；但是，给定类中的所有对象都使用相同的成员函数。 在内存中创建和放置成员函数的操作只能进行一次，即在类说明符中定义成员函数时进行。但是，数据项将具有不同的值，所以在每个对象中必须有每个数据项的单独实例。 对象1 对象2 数据1 数据1 数据2 成员函数1() 数据2 成员函数2() 对象3 数据1 数据2 （1）类与对象的关系是：（A、C）（选择两项） A、每个对象都有自己类的数据成员的副本 B、每个对象都有自己类的成员函数的副本 C、多个类对象共用自己类的成员函数 D、多个类对象不共用自己类的成员函数 20．静态数据成员和静态成员函数（48页） 说明静态成员要用关键字static，如果类中的数据项被定义为静态，那么只能为整个类创建一个这种数据项。而且静态数据只属于类而不属于对象。静态的数据成员是一个类的所有对象共享的信息。静态数据成员必须初始化，初始化的位置必须是在类定义之外，主函数之前。 （1）关于静态数据成员下列错误的是（D）（选择一项） A、说明静态数据成员时前边要加修饰符static B、静态数据成员要在类体外进行初始化 C、在类外引用公有静态的数据成员时，要在静态数据成员前加类名和作用域运算符 D、静态数据成员不是所有对象所共享的 （2）下面关于静态成员描述正确的是（A） A、静态成员不是对象的成员 B、静态成员是对象的成员 C、静态成员是对象的成员函数 D、静态成员是对象的数据成员 21．静态成员函数：（49页） 静态成员函数也用static来修饰。静态成员函数只能对类中的静态数据成员进行操作，不能操作非静态的数据成员。静态成员函数和静态数据成员一样，只属于类不属于对象，静态成员函数没有this指针。要调用一个静态成员函数不能使用对象，而直接用类名和作用域运算符来访问。例： class alpha { static int a; //静态数据成员 public: alpha() { a++; } static void print() //静态成员函数 { cout< operator <运算符> (<参数列表>) 习题： (1)下列运算符中，__运算符在C++中不能重载。（A） （A）？： （B）+ （C）-- （D）<= (2)重载运算符不能改变运算符的 和 。 （优先级，结合率） (3)关键字 引入了重载函数的定义。（operator） (4)重载运算符创建新的运算符。 （错误） 二、一元运算符重载 以 ++ 为例: (一) 调用运算符重载函数 void main( ) { sample s1; s1++; ++s1; s1.print(); } (二) 运算符重载函数返回类的对象 让运算符重载函数返回类的对象主要是实现： 运算后可以赋值的功能。 Sample operator++() sample s1,s2; { sample temp; temp.count=++count; return temp; } ※(三) 实现++运算符的后缀功能 再编写一个运算符重载函数 sample sample::operator++ { sample temp; temp.count=count; //原值赋给局部对象 count++; return temp; //返回带有原值的局部对象 } 三、二元运算符的重载 (1) 二元运算符的运算符重载函数 作为成员函数 ,包含一个形参，即 运算符右面的值。 sample s2,s1; s2+s1; (2) 重载赋值运算符 习题: (1)下列运算符重载的叙述中，正确的是(D) （A） 需要用关键字operator或virtual （B） 参数表列中一定要有参数 （C） 对于二元运算符重载需要两个参数 （D） 对一元运算符（++或--）进行后缀重载和前缀重载，需要通过参数表列来加以区别 (2) 当重载前缀（++）和重载后缀（++）时，编译器通过__来区分他们。 (3) 在类A 中有三个对象 a1,a2,a3,要使语句a3=a1*a2能够正确运行,重载的运算符*必须：(C) (A) 使用两个参数 (B) 不使用参数 (C) 将对象（重载的*运算符是该对象的成员）用作操作数 (D) 创建临时对象 四、复制构造函数 定义： sample ( sample &ptr) (一定是引用) 默认的复制构造函数 (相当于=运算符) 分类 自定义的复制构造函数 调用复制构造函数的地方: 习题： （1）赋值运算符合赋值构造函数两者的运算相似，只不过复制构造函数要创建一个对象。（错误）更正：正确 (2) 下列写法的区别是：（AD） 例：第一种：String s1; String s2=s1 第二种：String s1,s2; s2=s1; (A)第一种写法中应调用复制构造函数 (B)第一种写法中应调用赋值的运算符重载函数 (C)第二种写法中应调用复制构造函数 (D)第二种写法中应调用赋值的运算符重载函数 （3） 下列可调用复制构造函数的几种情况，说法不正确的是_D_。 （A） 当类的一个对象被初始化为同一类的另一个对象时 （B） 当一个对象作为参数被传递给一个函数时 （C） 当一个函数返回一个对象时 （D） 当类有两个已创建的对象，用其中一个对象对另一个对象赋 (4) 当函数按值返回值对象时,将调用＿。(复制构造函数) 五、转换函数 转换函数为成员函数,转换主要有以下几个类型： (1) 基本数据类型转换为对象。 在类中定义有一个参数的构造函数可实现转换。 (2) 将对象转换为基本数据类型。 在类中定义转换函数可实现 。 (3) 进行不同类中的对象间的转换 objectA = objectB; 目标类 源类 实现方法: 1.在目标类中使用带有一个参数的构造函数 2.在源类中使用转换函数 习题: (1) 编译器不会自动知道如何在用户定义类型和基本类型之间进行转换。 （正确） (2) 要将基本类型重定义为用户类型，需要使用＿ 。(带有一个参数的构造函数) (3) 关于类型转换函数有：（ ） (ABC) (A)从基本类型到用户定义类型可由带参的构造函数实现 (B)从用户定义类型到基本类型可由类型转换函数实现 (C)从用户定义类型到用户定义类型可由类型转换函数实现 (D)类型转换可由复制构造函数完成 第五章 继承 一. 继承概述： 优点: 代码的可重用性 代码可重用的结果是类库的开发 单继承: 是从现有的一个基类创建新类的过程。 继承规则: 子类继承基类所有的属性和方法，同时可以添加自己的属性和方法。 2. 单一继承 继承格式: class Chinese : public human 派生类类名 继承类型 基类名 继承下的类型访问规则： 基类 类外访问 派生类访问 自身访问 public 可以 可以 可以 private 不可以 不可以 可以 protected 不可以 可以 可以 四、初始化基类私有成员 class base class aa:public base { int x; { int y; public: public: base(int a=0) aa(int b,int c):base(b) {x=a;} {y=c;} }; }; 五、继承下构造函数与析构函数的调用 先调用基类的构造函数，在调用派生类的构造函数,析构函数与构造函数调用顺序相反。 六、继承下成员函数的调用 (1) 基类的成员函数，在派生类中没有被重定义 派生类对象可直接调用基类的成员函数 （2）基类的成员函数，在派生类中被重定义 用基类的对象调用成员函数，调用基类中的成员函数 用派生类的对象调用成员函数，调用派生类中的成员函数 用派生类的对象调用基类的成员函数，可用 类名：：函数名的 方式调用 七、派生类对象与基类之间的关系 习题: （1） 如果 Alpha继承类Beta,则类Alpha称为______，Beta称为______。 （2）派生类的对象可看作其相应基类的对象。(正确) （3）关于继承有：（ ）（三项）(BCD) (A) 共有继承时，基类的共有和私有成员作为派生类的共有成员 (B) 私有继承时，基类的共有和保护成员作为派生类的私有成员 (C) 保护继承时，基类的共有和保护成员作为派生类的保护成员 (D) 无论何种继承，派生类的成员函数都不能访问基类的私有成员 （4）下列关于派生类访问基类成员的描述，（ ）是正确的(一项) (3) （1） 派生类对象可以使用基类中的public，protected，和private成员 （2） 派生类只能访问基类的private成员 （3） 派生类不能访问基类的private成员 （4） 派生类不能访问基类的任何成员 (5) 派生类的构造函数的成员初始化列表中，不能包含__。(c) （A） 基类的构造函数 （B） 派生类中成员对象的初始化 （C） 基类的成员对象初始化 （D）派生类中一般成员变量的初始化 (6) 公有派生的类的成员函数不能访问基类的__成员。(A) (A) 私有成员 (B) 保护成员 (C) 公有成员 (D) 数据成员 （7）在单继承中，构造函数执行的顺序是：正确答案（1） a 初始化基类对象 b 初始化成员对象，按照他们在类的声明中出现的顺序 c 初始化派生类对象 （1）a ->b-> c （2）a->c->b （3）c->b->a （4）b->c->a (8) 下列程序输出：(A) class A { public: void fn2() { cout<<”A”;} }; class B:public A { public: void fn2(int i) { cout<<”B”< class A { public: A() { cout<<”A”;} }; class B:public A { public:B() { cout<<”B”;} } class C:public B { public: A a; C():B() { cout<<”C”;} }; void main() { C c; }正确答案：ABAC (A) B A C (B) A B C (C) C A B (D) B A C 第六章 多重继承和多态性 一、多重继承概述 多重继承：从多个基类中创建一个新类的过程。 继承规则：同单一继承。 多重继承格式： class teach_ass : public teacher , public student 派生类名 第一个基类 第二个基类 多重访问下的类型访问规则: 同单一继承。 初始化基类私有成员：同单一继承，多个基类用逗号隔开。 二、多重继承下的构造函数和析构函数的调用 先调用基类的构造函数，在调用派生类的构造函数，多个基类按照继承的列表从左向右调用，析构函数与构造函数相反。 三、多重继承下的成员函数的调用 当多个基类中有相同的成员函数时，用派生类的对象调用会产生多义性。 解决方法: (1) 在调用时，指明该成员函数所在的类。 类名：：成员函数名 (2) 在派生类中重定义该成员函数，这样用派生类对象调用成员函数时，调用的就是派生类中的成员函数。 四、虚基类 虚基类的使用： class teacher : virtual public person class student : virtual public person person 类成为虚基类，在助教类中不会再有person类成员的两个副本了。 习题： (1)c++提供了_____，它允许派生类从多个基类中继承，即使这些基类互不相干。 (2) 使用虚基类的目的是__。 (A)简化程序 （B）消除二义性 (C)提高运行效率 (D)减少目标代码 (3) 在多重继承下派生类(类中有成员对象)的对象初始化时构造函数的调用顺序是 （A） 基类构造函数按照在派生类中基类列表的顺序,派生类中成员的构造函数,派生类的构造函数 （B） 基类在派生类继承的顺序,派生类中成员的构造函数,派生类的构造函数 （C） 派生类中成员的构造函数,派生类的构造函数,基类在派生类继承的顺序 （D） 派生类中成员的构造函数,基类在派生类继承的顺序,派生类的构造函数 (4) 关于虚基类的使用，下列说法正确的是：（选择两项） (A) 避免多级派生时，基类成员副本的多重拷贝 (B) 避免成员访问的二义性 (C) 不能建立虚基类的对象 (D) 虚基类中一定包含虚函数 (5) 从多个基类创建新类的过程称为_ _。 五、多态性 概念：同一个操作作用在不同的对象上有不同的操作和结果。 多态性的实现： （1）继承 （2）虚函数 class CShape { public: virtual void draw( ) { cout<<“形状\n”; } }； class CRect : public CShape { public: void draw( ) { cout<<”矩形\n”; } }; class CEllipse : public CShape { public: void draw( ) { cout<<”椭圆\n”; } }; }; 纯虚函数: 当基类中的虚函数无须去实现时(例如，形状类 draw是没有实际意义的)，就可以把他声明成为纯虚函数。 声明形式： virtual 函数名（）=0; 纯虚函数的实现在派生类中。 抽象类: 含有一个或多个纯虚函数的类就成为了抽象类。 作用：抽象类就是用来被继承的。 抽象类不能创建对象 动态绑定： 静态绑定: 根据指向对象的指针类型，静态（在编译时）选择成员函数。（早期绑定） 动态绑定: 根据对象的类型而不是指向该对象的指针类型进行动态（在运行时）选择成员函数。（后期绑定） “虚”成员函数进行动态绑定 动态绑定是虚函数的结果 虚析构函数: 当通过基类的指针删除一个派生类对象时，为了能够有效的释放空间，需要虚析构函数。 Class A class B :public A { { public: public: ~A(){cout<<”a”<getdata();将调用_____类的函数。(基类) (5) 在运行时解决的函数调用成为_____绑定，编译时解决的函数调用成为______绑定。 (动态绑定、静态绑定) (6)关于动态联编下列描述中，__是错误的。(d) （A） 动态联编是以虚函数为基础的 （B） 动态联编是在运行时确定所调用的函数代码的 （C） 动态联编调用函数操作是指向对象的指针或对象引用 （D） 动态联编是在编译时确定操作函数的 (7) 关于纯虚函数和抽象类的描述中，__是错误的。 (c) （A） 纯虚函数是一种特殊的虚函数，它没有具体的实现 （B） 抽象类是指具有纯虚函数的类 （C） 一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类 (D) 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出 (8)下列描述中，__是抽象类的特征。(d) (A) 可以说明虚函数 (B)可以进行构造函数重载 (C) 可以定义友元函数 (D)不能说明其对象 (9) 程序员定义一些类,但不需要把这些类实例化成任何对象,这些类是__。 （b ） （A） 虚基类 (B)抽象类 (C)基类 (D)虚抽象类 (10) 当通过基类指针删除一个派生类对象时,需要__。 （c ） （A） 虚构造函数 (B)纯虚函数 (C)虚析构函数 (D)虚析构函数和虚构造函数 (11)_是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。 （c） （A） 虚析构函数 (B)虚构造函数 (C)纯虚函数 (D)静态成员函数 (12) 下列关于动态绑定的描述（）是正确的（选择两项）正确答案：AD (A) 使用虚函数可以实现动态绑定 (B) 使用虚函数是为了实现静态绑定 (C) 在编译阶段确定函数的调用，体现了动态绑定 (D) 在运行阶段确定函数的调用，体现了动态绑定 (13) 下列关于多态性的描述，（）是正确的（选择一项）正确答案：A (A) 多态性表示同一行为可以有不同表现 (B) 多态性使得同一属性在不同子类中具有不同的特性 (C) 多态性有利于信息隐藏 (15) 使同一函数在不同的类上具有不同的行为称为__。(多态性) (16) 在类定义中纯虚函数的定义是通过__实现的。(=0) (17) 继承具有_ _，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。(传递性) 编程题: 1．统计工人的个人工资情况，工资包括两部分：一部分是工人的固定工资，另一部分是加班的小时工资。当程序输入工人的姓名、固定工资和加班小时后，能计算工人的总工资。每个工人的加班工资都是一样的。 (用静态数据成员做) #include class Salary { private: char name[10];//姓名 int baseSalary;//基本工资 static int hourSalary; //静态数据成员，因为所有人的加班工资都一样 int hour;//工作小时 int count;//总工资数 public: Salary();//构造函数 void getInfo();//基本录入 void countSalary();//计算工资 void print();//输出工资 }; Salary::Salary() { baseSalary=0; hour=0; count=0; } void Salary::getInfo() { cout<<"请输入姓名:"; cin>>name; cout<<"请输入本月的基本工资:"; cin>>baseSalary; cout<<"请输入本月加班小时数:"; cin>>hour; } void Salary::countSalary() { count=baseSalary+hour*hourSalary; } void Salary::print() { cout< class Time { private: int hour,minute,second; public: Time(int=0,int=0,int=0); Time operator++();// ++运算符重载函数,前缀 Time operator++(int);// ++运算符重载函数,后缀 Time operator+(Time);// +运算符重载函数 int get_h(); int get_m(); int get_s(); }; Time::Time(int h,int m,int s)//构造函数,初始化 { hour=h; minute=m; second=s; } Time Time::operator++() //自增运算符前缀重载函数 { second++; //加一秒 if(second>=60)//判断进位 {minute++; second-=60;} if(minute>=60)//判断进位 {hour++; minute-=60;} hour=hour%24; return(*this);} Time Time::operator++(int)//自增运算符后缀重载函数 { Time temp(hour,minute,second);// 创建临时对象并初始化 second++;//加一秒 if(second>=60) //判断进位 {minute++; second-=60;} if(minute>=60) //判断进位 {hour++; minute-=60;} hour=hour%24; return(temp); } Time Time::operator +(Time t) //+运算符重载函数 { Time temp; temp.hour=hour+t.hour; temp.minute=minute+t.minute; temp.second=second+t.second; if(temp.second>=60) //判断进位 { temp.minute+=temp.second/60; temp.second=temp.second%60; } if(temp.minute>=60)//判断进位 { temp.hour+=temp.minute/60; temp.minute=temp.minute%60; } return temp; } int Time::get_h() { return hour; } int Time::get_m() { return minute; } int Time::get_s() { return second; } void main( ) { Time time1(2,30,40),time2(1,40,50),time3(0,0,0); time3=(time2++)+(++time1);//+和++运算符操作的是类对象时，就要调用重载函数 cout< class CShape { public: virtual void draw( ) //基类中的函数为虚函数 { cout<<"形状\n"; } }; class CRect : public CShape //派生出矩形类 { public: void draw( ) //重定义draw 函数 { cout<<"矩形\n"; } }; class CEllipse : public CShape //派生出椭圆形类 { public: void draw( ) //重定义draw 函数 { cout<<"椭圆\n"; } }; void main() { CShape *ptr; //创建基类的指针 CRect r;//创建派生类矩形类的对象 CEllipse e;//创建派生类椭圆形类的对象 ptr=&r; //基类的指针指向派生类矩形类的对象 ptr->draw( ); //基类指针调用draw 函数 ptr=&e; //基类指针指向派生类椭圆形类的对象 ptr->draw( );//基类指针调用draw 函数 } 复习题一 1）下列关于函数重载的描述，（）是正确的。（选择两项）正确答案：AbD A、函数重载定义了一组名称相同的函数，使用的参数列表相同。 B、函数重载定义了一组名称相同的函数，使用的参数列表不同。 C、函数中的同名函数可以构成函数重载。 D、子类中的函数和父类中的函数同名且参数列表不同，不能构成函数重载。 2) 在C++中，指出下列（）是类smple的构造函数。（选择一项）(A ) A、sample(); B、void~sample(); C、~sample(); D、~sample(int,sample); 3） #include #include class string { public: char*str; string(char*s="") { int len =strlen(s); str=new char[len+1]; strcpy(str,s); } ~string() { delete[]str; } void display() { cout< class base1 { public: base1(){cout<<”base1”;} }; class base2 { public: base2(){cout<<”base2”;} }; class A:virtual public base1{}; // 虚基类为了解决二义性而存在：使公有的基类在派生类中只有一个复制。这个理解上有点问题！ class B:virtual public base1{}; class C:virtual public base2{}; class D:virtual public base2{}; class OBJ:public A,public B,public C,public D { public: OBJ(){cout<<”obj”;} }; void main(){OBJ obj;} 编译运行上面的C++程序，结果是（）。（选择一项）(C ) A、obj base1 base2 B、base2 base1 obj C、base1 base2 obj D、obj base2 base1 9)#include void func(int x) { x++; cout< class sample { private: int data; public: sample(int x){data=x; cout< class Base { public: virtual void display(){cout<<"Base";} }; class A:public Base { public: void display(){cout<<"A";} }; class B:public Base { public: void display(){cout<<"B";} }; void main() { A obj1; B obj2; Base*obj; obj=&obj1; obj->display(); obj=&obj2; obj->display(); } // 理解虚函数的意义就可以了 上面C++程序的运行结果是（）（选择一项）正确答案：A A、A B B、B A C、A Base D、Base Base 3．在C++语言中，下列语句中，正确的是（）（选择一项）(D) A、void main(){cout< class sample{ private: int data; public: sample(int x){data=x;cout< class sample; class example { private: int data; public: example(){data=10;} void display(sample); }; class sample { private: int data; public: sample(){data=20;} friend void example::display(sample); }; void example::display (sample obj){cout< class example { private: static int num; public: example(){num++;cout< class A{ public: ~A(){cout<<”A destroy”<<” “;} }; class B{ public: ~B(){cout<<”B destroy”<<” “;} }; class C:public A,public B{ // 注意继承的顺序 public: ~C(){cout<<”C destroy”<<” “;} }; void main(){C obj:} 上面C++程序运行的结果是（）（选择一项）(B) A、A destroy B destroy C destroy B、C destroy B destroy A destroy C、C destroy A destroy B destroy D、B destroy A destroy C destroy 11．#include class example { private: int day,year; public: int month; void display(); }; void example::display(){cout<display(); C、C obj;obj.A::display(); // 函数加了作用域之后就不会出现二义性了！ D、C obj;obj.B::display(); 16．（）属性可以从类定义的外部来存取，而（）属性不可以从类定义的外部来存取。（选择一项） ( D ) A、私有的，保护的 B、保护的，公共的 C、私有的，公共的 D、公共的，私有的 17．在C++，下列关于this指针的描述，正确的有（）。（选择两项） (B C) A、不能使用this指针来显示引用对象的成员。 B、this 指针指向调用的成员对象的地址。 C、this指针可以像对象指针一样使用，借助箭头运算符->来访问所指向的对象的成员。 22．分析下面的C++程序： class sample { private: int num; public: void display(); }; void main(){ sample object1; sample object2; object1.display(); object2.display(); } 下列描述（）是正确的。（选择两项）(B D) A、程序运行时，对象object1,object2公用num的存储空间 B、程序运行时，对象object1,object2的成员num分别存储在各自对象的存储空间 C、程序运行时，对象object1,object2执行display成员函数时，执行的代码分别存储在各自对象的存储空间 D、程序运行时，对象object1,object2执行display成员函数时，执行的代码公用同一存储空间 void sample::operator++() { count++; } 调用运算符重载函数返回 temp 对象,赋值给 s2。 s2 s1++; s2=++s1; 对于重载的增量和减量运算符，首先执行运算符重载函数，而不管运算符是后缀还是前缀。要区别后缀和前缀运算，必须定义不同的运算符函数。 Int 专门用来区分前后缀的 ( int ) Sample operator++() 前缀调用 Sample operator++(int) 后缀调用 s2.operator+(s1); = 默认行为是复制类的数据成员。 对于有指针成员的类，有时这是很危险的，需要重载赋值运算符。 当类中有指针数据，并且用new分配内存时 当类的对象初始化该类的另一个对象时 当对象被作为参数按值传递给一个函数时 当函数按值返回一个对象时 ※ 派生类不能直接访问基类中的私有成员 派生类的对象是基类的对象，但基类的对象不是派生类的对象。所以，基类的指针可以指向派生类的对象，而派生类的指针不能指向基类的对象。 根据继承规则，teacher类继承person类所有的属性方法，student类继承person类所有的属性方法。助教类多重继承teacher和student类，这样助教类中会有两份person类成员的副本，解决这个问题就要把person类变成虚基类。 person person 助教 student teacher 只有使基类中的成员函数成为虚函数，并且在派生类中重定义该成员函数，这样当基类指针指向了派生类的对象，且用基类指针调用成员函数时，可以调用到该派生类中的成员函数，否则调用的就是基类中的成员函数。 void main() {  结果： CShape *ptr; 矩形 CRect r; 椭圆 CEllipse e; ptr=&r; ptr->draw( ); ptr=&e; ptr->draw( ); } 结果： a 由于用的是基类的指针指向派生类的对象，当用基类指针删除派生类的对象时，调析构函数，如果基类析构函数不是虚函数，则只调基类析构函数 PAGE 25