2023年面向对象程序设计总复习资料.doc

面向对象程序设计总复习(2023_夏)

复习之一、对照书本(或上课课件)上，搞懂有关概念
【第0-1章】
1. 面向对象程序设计是不同于传统程序设计的一种新的程序设计范型。它对减少软件的复杂性,改善其重用性和维护性，提高软件的生产效率,有着十分重要的意义。因此面向对象的程序设计被认为是程序设计方法学的一场实质性的革命(在导学中)。
2. 面向对象（O-O）程序设计是一种新的程序设计范型。这种范型的重要特性是：
程序=对象+消息
面向对象程序的重要结构特点是：
第一，程序一般由类的定义和类的使用两部分组成；
第二，程序中的一切操作都是通过向对象发送消息来实现的，对象接受到后，启动有关方法完毕相应操作。
3. 现实世界中，对象一般可以表达为：属性+行为
现实世界中的对象，具有以下特性：
(1) 每一个必须有一个名字以区别于其他对象；
(2) 用属性来描述对象的某些特性；
(3) 有一组操作，每组操作决定对象的一种行为；
(4) 对象的行为可以分为两类：一类是作用于自身的行为，另一类是作用于其他对象的行为。
4. 在现实世界中，类是一组具有相同属性和行为的对象的抽象。
类与对象的关系是抽象和具体的关系。
在C++面向对象的程序设计中，把类中的属性称为数据（数据成员），类中的操作是用函数（函数成员）来实现的。
5. 面向对象程序设计的基本特性：抽象性、封装性、继承性和多态性
(1). 抽象是通过特定的实例（对象）抽取共同性质后形成概念的过程。
(2). 在面向对象程序设计中，封装是指把数据和实现操作的代码集中起来放在对象内部，并尽也许隐蔽对象的内部细节。
(3). 继承机制允许派生类继承基类的数据和操作(即数据成员和成员函数)，也就是说，允许派生类使用基类的数据和操作。同时派生类还可以增长新的操作和数据。
从继承源上分，继承分为单继承和多继承。
(4). 面向对象系统的多态性是指不同的对象收到相同的消息时产生多种不同的行为方式。如可以有同名函数
【第2章】
6. 简朴的C++程序
例2.1 计算两个整数之和sum.cpp
这两行也可用一行代替：#include <iostream.h>
#include <iostream> //系统头文献
using namespace std;
int main( ) //主函数
{ int x , y, sum; // 定义三个整型变量
cout<<"输入二个数:"<<'\n'; //界面:提醒用户输入二个数
cin>>x; //从键盘输入变量x的值
cin>>y; //从键盘输入变量y的值
sum=x+y;
cout<<“x+y="<<sum<<'\n'; //输出
return 0;
}
C++新行(回车换行) '\n’ 或endl (ENDL的小写)
新的输入/输出：
老：scanf
新：cin是标准输入流，在程序中用于代表标准输入设备，即键盘。运算符“>>”表达向右
老：printf
新：cout是标准输出流，在程序中用于代表标准输出设备，即屏幕。运算符“<<”表达向左
使用cin或cout进行I/O操作时，在程序头中头文献#include <iostream.h>
7. 函数原型（函数声明）(重点)
返回值类型 函数名（参数表）；
例2.7
int add(int a, int b);
int add(int, int);
使用在前，定义在后，要先声明。
若定义在前，使用在后，就可不必声明。
8. 函数重载：C++中，只要函数的參数的类型不同，或者參数个数不同，或者二兼有之，几个函数可以用相同的函数名。称为函数重载
9．C语言用函数malloc()和free()动态分派内存和释放动态分派的内存。C++使用运算符new和delete能更好、更简朴地进行内存的分派和释放。
10. 引用(重点)
引用可为变量起别名，它重要用作函数参数以及函数的返回类型。引用有三种：（1）有变量的引用、（2）参数引用和（3）返回值引用。
11．1、& 取地址运算符 取西瓜皮
2、* 指针运算符（间接访问运算符）挖西瓜馕
【第3章】
12. C++中说明（类的定义）类的一般形式为
clsaa 类名 {
[ private:] (可省略)
私有段数据成员和成员函数
protected:
保护段数据成员和成员函数
public:
公有段数据成员和成员函数
};
成员函数的定义方式：
第一种方式是在类定义中只给出成员函数的原形，而成员函数体在类的外部定义。
第二种方式是将成员函数定义在类的内部，即定义为内置函数。
(1) 隐式定义
(2) 显式定义
13．类对象中成员的引用（使用、访问都是同一个意思）
不管是数据成员，还是成员函数，只要是公有的，就可以被外部函数直接引用，引用的一般格式是：
对象名. 数据成员名 和 对象名. 成员函数名（实参表）
外部函数不能引用对象的私有成员
总之：类成员的访问属性：
类的公有成员不仅可以被类中成员函数访问，还可以在类的外部通过类的对象进行访问。类的私有成员只能被类中成员函数访问，不能在类的外部通过类的对象进行访问。
14. 构造函数的特点：
（1）构造函数的名字必须与类名相同，否则编译程序将把它当作一般的成员函数来解决。
（2）构造函数没有返回值，在声明和定义构造函数时，是不能说明它的类型的的，甚至说明为void类型也不行。
（3）构造函数也是成员函数，与普通的成员函数同样，构造函数的函数体可写在类体内，也可写在类体外。
（4）一般不提倡在构造函数中加入与初始化无关的内容
（5）构造函数一般声明为公有成员。它不需要用户来调用，而是在建立对象时自动执行的。
（6）在实际应用中，通常需要给每个类定义构造函数。假如没有给类定义构造函数，则编译系统自动地生成一个缺省的构造函数。
complex::complex( ) { } //不能带任何参数。
（7） 定义构造函数时，也可以是不带参数的。
15. C++允许重载构造函数，这些构造函数之间名字相同，而以它们所带参数的个类或类型的不同而区分。带默认参数的构造函数。
16．对象的赋值和拷贝构造函数，其作用是，在建立新对象时，使用一个已经存在的对象去初始化这个新对象。piont p2(p1);
17. 析构函数也是特殊成员函数，用于释放对象。
（1） 析构函数与构造函数名字相同，但它前面必须加一个波浪号（~）。
（2） 析构函数没有参数，也没有返回值，并且不能重载，因此在一个类中只能有一个析构函数。
（3） 当撤消对象时，编译系统会自动地调用析构函数。
18．可以用类定义对象数组：
类名 数组名[元素个数]；
19．当需要时，可以用类定义对象指针。对象指针就是用于存放对象地址的变量
类名 *对象指针名;
20. 类的封装性，使类只能通过成员函数来访问私有成员。这是好事但也有一定的限制太死的感觉。能否开个小孔口，必要时作个破例，使外界函数、别的类的个别成员函数、甚致别的类的所有成员函数可访问某个类的私有成员。这个方法称为友元。
21. 友元涉及友元函数和友元类
(1) 友元函数分为：非成员函数作友元和别的类的成员函数作友元
(2) 友元类： 在类定义时，在类内说明一个类(该类前面已定义)，前加上 friend表达该整个的一个类是本类的友元类。友元类的所有成员函数可以访问它自己类私有成员又可本类的私有成员。
【第4章】
22. 派生类的定义
基类：
class 基类名
{
类的内容
};
声明派生类：
class 派生类名 : 继承方式 基类名
{
//派生类新增的数据成员和函数成员
};
继承方式可为公有继承(用public)、私有继承(用private或缺省)和保护继承(用protected)
23. 基类成员在派生类中的访问属性(重点)
基类中的成员
在公有派生类中的访问属性
在私有派生类中的访问属性
在保护派生类中的访问属性
私有成员
不可直接访问
不可直接访问
不可直接访问
公有成员
公有
私有
保护
保护成员
保护
私有
保护
24. 派生类对基类成员的访问规则(重点)
(1) 私有继承的访问规则
基类中的成员
私有成员
公有成员
保护成员
访问方式
内部访问
对象访问
不可访问
不可访问
可访问
不可访问
可访问
不可访问
(2) 公有继承的访问规则
基类中的成员
私有成员
公有成员
保护成员
访问方式
内部访问
对象访问
不可访问
不可访问
可访问
可访问
可访问
不可访问
(3) 保护继承的访问规则
基类中的成员
私有成员
公有成员
保护成员
访问方式
内部访问
对象访问
不可访问
不可访问
可访问
不可访问
可访问
不可访问
25. 派生类的构造函数和析构函数
(1) 派生类的构造函数和析构函数执行顺序
无论何中派生，当创建派生类对象时，一方面执行基类的构造函数，随后再执行派生类的构造函数；当撤消派生类对象时，则先执行派生类的析构函数，随后再执行基类的析构函数。
(2). 派生类的构造函数和析构函数的构造规则
简朴的派生类的构造函数一般格式为：
派生类名(参数总表):基类名(参数表)
{
派生类新增成员的初始化语句
}
其中基类构造函数参数，来源于派生类的构造函数的参数总表，也可以用常数值。
26. 从多个类，派生出一个类，也即一个类从多个基类继承称为多重继承。
多重继承的声明格式如下：
class 派生类名: 继承方式1 基类名1, ... ,继承方式n 基类名n
{
派生类新增的数据成员和成员函数
};
派生类继承了基类1 到 基类n的所有数据成员和函数成员，其访问属性规则与单继承情况同样，多继承可当作单一继承的扩展。
27. 假如一个派生类有多个直接基类，而这些直接基类又有一个相同的基类，则在最低层的派生类中会保存这个间接的共同基类数据成员的多份同名成员。在访问这些同名成员时会产生二义性，才考虑虚基类，虚基类在派生类中声明的形式：
class 派生类名： virtual 继承方式 基类名{
// ............
};
通过这样的声明后，当基类通过多条派生途径被一个派生类继承时，该派生类只继承该基类一次，也就是说，基类成员无“副本”
【第5章】
28. 编译时的多态性与运营时的多态性
静态联编（前期联编）
静态联编规定在程序编译时就知道调用哪个函数，就决定如何实现某一动作。
动态联编（后期联编、滞后联编）
一直要到程序运营时才干拟定调用哪个函数。系统在运营时才动态完毕的联编。
静态联编支持的多态性称为编译时多态性，也称静态多态性。在C++中，编译时多态性是通过函数重载和运算符重载实现的。
动态联编支持的多态性称为运营时多态性，也称动态多态性。在C++中，运营时多态性是通过继承和虚函数来实现的。
29．运算符重载：C++除了可以对函数重载外，还可以对大多数运算符实行重载。
外部普通函数 类的友元函数 是类的成员函数
成员运算符函数定义的语法形式
成员运算符函数的原型在类的内部声明格式为：
class X{
//...
返回类型 operator 运算符(形参表)；
//...
};
30. 虚函数的引入，基类的指针可以指向它的公有派生类的对象，用“指针”才有虚函数的问题。
引入派生类后，由于派生类是由基类派生出来的，因此指向基类的指针和指向派生类的指针是相关的：
（1）基类的指针可以指向它的公有派生类的对象。但不允许指向它的私有派生类的对象。
（2）派生类的指针不允许指向它的基类的对象。
（3）基类的指针指向它的公有派生类的对象时，只能用它来直接访问派生类中从基类继承来的成员，而不能直接访问公有派生类中定义的新成员。
31．有时在程序设计时，使用对象指针的目的是为了动态和灵活，即当指针指向不同对象（基类对象或派生类对象）时，能分别调用不同类的成员函数。
假如将函数说明为虚函数，就能实现这种动态调用的功能。
虚函数的定义是在基类中进行的：
virtual 函数类型 函数名(形参表)
{
函数体
}
32．纯虚函数的一般形式如下：
virtual 函数类型 函数名(参数表)=0；
假如一个类至少有一个纯虚函数,那么就称该类为抽象类
【第6章】
33. 模板的概念
模板是C++语言的一个重要特性。模板是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了代码重用，使得一段程序可以用于解决多种不同类型的对象，大幅度地提高程序设计的效率。
34．函数模板和类模板
（1）.函数模板与模板函数
所谓函数模板，就是写一个函数模子，用这个模子套印出许多功能相同，参数类型和返回类型不同的函数。模板函数：函数模板实例化后的具体函数。
（2） 类模板和模板类
类模板 (也称为类属类或类生成类)是：允许用户为类定义一种模子，使得类中的某些数据成员，某些成员函数的参数或者返回值，能取任意数据类型

【第7章】
35．C++流概念：cin >>对象;
cout<<对象;
整型、实型、字符、字符串等有格式的输入输出
36. 文献的输入输出：
在具有文献操作的程序中，必须有如下的预解决命令： # include <fstream.h>
open、close函数
文本文献、二进制文献读写。

复习思考题、即考试的A、B、C、D选择题和填空题
一、分清下面的概念，那些是对的的，那些是错误的
1. 面向对象程序的重要结构特点之一
√程序一般由类的定义和类的使用两部分组成。√程序中的一切操作都是通过向对象发送消息来实现的。×程序中的一切操作都是通过调用函数来实现的。×程序一般由函数定义和函数的使用两部分组成。×程序一般由变量的定义和变量的使用两部分组成。×程序一般由对象的定义和对象的使用两部分组成。×程序中的一切操作都是通过定义函数来实现的。×程序中的一切操作都是通过定义类来实现的。
2．对象是现实世界中的一个实体，其特性
√每个对象必须有一个名字，以示区别。√有属性描述。√有一组操作。√创建对象时会自动调用构造函数。×必须有一个关键字。×一定要自定义一个构造函数。×要有二个以上数据。
3．面向对象系统的特性是
√抽象性 √封装性 √继承性 √多态性 ×完整性 ×唯一性 ×二义性 ×安全性
4．类的概念是
√对一组具有共同的属性特性和行为特性的对象的抽象。√同一类数据的集合。×类即是对象数组。×各种对象的集合。×同一记录的集合。×同类函数的集合。×现实世界中所有对象的集合。
5．类和对象之间的关系是
√抽象和具体的关系。√类型和变量之间的关系。√结构类型和结构体的关系。×定义和被定义的关系。×调用和被调用的关系。×类即是对象数组。×型和值的关系。×指针和所指的对象的关系。
6．构造函数的特性
√构造函数的函数名与类名完全相同。√构造函数可以有形式参数。√构造函数可以重载。√在创建对象时被执行。×在程序编译时被执行。×在创建类时被执行。×在程序装入内存时被执行。×构造函数必须说明返回类型。×程序中要有调用构造函数的语句。
7．析构函数的特性
√一个类中只能定义一个析构函数。√析构函数名与类名相同并加~。√系统会自动调用析构函数。×析构函数的定义只能在类体内。×析构函数可以有多个参数。×一个类中能定义多个析构函数。
8． 关于成员函数特性的下述描述
√成员函数可以重载。√成员函数可以设立参数的缺省值。√成员函数可以是静态的。√类定义中只给出成员函数的原型，而成员函数在类外定义。√类定义中只给出成员函数的原型，而成员函数在类外定义并在之前加inline。√可在类内定义。×成员函数一定要在类内定义。×成员函数一定是内置函数。
9．下列的各种函数中，是本类的成员函数
√构造函数 √析构函数 √拷贝构造函数 √缺省参数的构造函数 ×友元函数 ×主函数 ×普通函数 ×标准函数
10. 在友元函数的下面说法中，对的的是：
√友元函数是独立于当前类的外部函数。×一个友元函数不能同时定义为两个类的友元函数
×友元函数必须在类的外部定义。×在外部定义友元函数时，必须加friend
11．友元的作用是什么，一个类的友元可以访问该类的什么
√提高程序的运营效率。×加强类的封装性。×实现数据的隐藏性。×增长成员函数的种类
√所有成员 ×只能是私有成员 ×只能是公有成员 ×成员函数
12．对基类和派生类的关系描述中
√派生类(如公共汽车)是基类(汽车)的子集。√派生类是基类定义的扩延。√无论哪种派生，基类的私有成员不允许派生类的成员函数访问。√无论哪种派生，基类的公有成员允许派生类的成员函数访问。√无论哪种派生，基类的保护成员允许派生类的成员函数访问。×派生类是基类的具体化。 ×派生类是基类的组合。×无论哪种派生，基类的保护成员不允许派生类的成员函数访问。
13．派生类的对象对它的基类成员中，可以访问的是
√公有继承的公有成员。×公有继承的保护成员。×公有继承的私有成员。×公有继承的所有成员。×私有继承的公有成员。×私有继承的私有成员。×私有继承的所有成员。×私有继承的保护成员。
14. 对虚基类对的的论述
√ 定义派生类时，在基类名前加virtual。×定义基类时加virtual。×成员函数前加virtual。×在派生类名前加virtual。
15．一个派生类有多个父类，而这多个父类又有一个共同基类，这种情况，才考虑设立虚基类，其目的是：
√消除二义性。 简化程序。 提高运营效率。 减少目的代码。
16．C++中函数可以重载：（P31）
√只要函数参数的类型不同，√或者参数的个数不同，√或者两者兼有之，两个以上函数可以同名。
17．不可重载的函数的是：√析构函数。（可以：）普通的成员函数。 友元函数。 外部函数。
18．可定义作运算符重载函数的是
√成员函数。√友元函数。√类以外的函数。×析构函数。×无返回值的函数。×构造函数。
19．不能重载运算符
√:: √? : && [ ] new ++ ( ) delete
20．关于动态联编的描述，动态联编称为运营时的多态性是通过什么来实现的。
√动态联编是以虚函数为基础的。√动态联编是在运营时拟定所调用的函数的。√动态联编调用的函数，是用基类对象的指针或对象引用所指的函数。√继承和虚函数。动态联编是在编译时拟定操作函数的。函数重载和运算符重载。 运算符重载。 函数重载。
21．说白了，通过基类指针或引用来访问基类和派生类中的同名函数，才考虑虚函数。其描述：
√虚函数是在基类中用virtual 说明，派生类中重新定义的函数。×虚函数是一个static类型的成员函数。 ×虚函数是一个非成员函数。×派生类的虚函数与基类的虚函数具有不同的参数个数和类型。
22．抽象类论述：
√假如一个类至少有一个纯虚函数，那么该类为抽象类。√抽象类只能用作其他类的基类，不能建立抽象类对象。√抽象类可以用来定义指针。×抽象类可以作为某个函数的返回类型。
23．进行文献操作时需要包含的文献，C++用cout 和 cin 进行输出/输入操作时需要包含文献。
√fstream.h √iostream.h stdio.h stdlib.h string.h math.h
24. 面向对象程序设计是不同于传统程序设计的一种新的程序设计范型。面向对象的程序设计被认为是程序设计方法学的一场实质性的革命(在导学中)。
25. 面向对象（O-O）程序设计是一种新的程序设计范型。这种范型的重要特性是：
程序=对象+消息
26. 现实世界中，对象一般可以表达为：属性+行为
27．在定义类时，第一个保存字。 （class）
28．将数据结构和作用于数据结构上的操作组成一个实体，数据的表达方式和对数据的操作细节被隐藏起来，这是面向对象程序设计的 （封装性）。而函数重载是 （多态性）。
29．C++中类的定义内部，英文private段 ，protected 段，public段（私有段 保护段 公有段 ）
30. 定义了类A，在主函数中如出现: A *p, obj, ob[10]; 的语句。（则p是对象指针、obj是对象、ob是对象数组。）
31．C++的运算符：<< >> new delete (输入 输出 申请 释放)
32． 在C++定义的类中，成员可分为二类，有三个段。（数据成员 函数成员 私有 公有 保护）
33． 在一个类定义中，可以声明友元，友元可以是三种友元。（友元函数 友元成员 友元类）
34． C++中，函数说明为void fun(int &i)的引用叫，( 参数引用 ) ，函数说明为void &fun(int i)的引用叫。( 返回值引用 )
35． 继承机制允许派生类继承基类的什么，( 数据和操作 )同时，派生类还可以增长新的什么。( 数据和操作 )
36．类外的函数作运算符重载时，只能访问类的( 公有 )成员，而用类的友元运算符函数或成员运算符函数重载可以访问类的（ 所有 ）成员。
37．一个类模板允许用户为类定义什么？（一个模式(子) ）使得类中的某些数据成员、某些成员函数的参数或返回值，能取什么类型？（任意数据类型）
38. 模板是实现代码重用机制的一种工具，函数模板的实例化、类模板的实例化分别称为（模板函数 、模板类）

复习之二、阅读程序写运营结果、程序填空（把这些程序真正读懂，不要背答案！）
1. 函数、函数调用、函数原型（涉及参数引用、返回值的引用）
2. 类的定义和定义对象(涉及对象指针)
3. 派生和继承的应用
4. 派生类的构造函数和析构函数执行顺序
5．函数重载和运算符重载
复习思考题
1.
#include <iostream.h>
int add(int , int );
int main()
{ int x, y, sum;
cout<<”输入二个整数:”;
cin>>x>>y;
sum=add(x,y);
cout<<”x+y=”<<sum<<endl;
return 0;
}
int add(int a, int b)
{ int c;
c=a+b;
return c;
}
答案：输入二个整数: 10 20
x+y=30
2.
#include <iostream.h>
void fun1(int i)
{ i += 5;
}
void fun2(int &i)
{ i += 15;
}
void main( )
{ int k=10;
fun1(k);
cout<<"k="<<k;
fun2(k);
cout<<" k="<<k<<endl;
}
答案： k=5 k=15
3．
#include <iostream.h>
int &f(int &i)
{ i+=10;
return i;
}
int main( )
{ int k=0;
int &m=f(k);
cout<<k<<’,’;
m=20;
cout<<k<<endl;
return 0;
}
答案： 10, 20
4．
#include <iostream.h>
class Point {
public:
Point( int x1=0, int y1=0) {
x=x1; y=y1;
}
void print();
private:
int x, y;
};
void Point::print() {
cout<<"x="<<x<<" y="<<y<<endl;
}
void print(Point p) {
p.print();
}
void main()
{ Point p1(10,20),p2(30),p3,*p;
p=&p1;
p->print();
p2.print();
print(p3);
}
答案： x=10 y=20
x=30 y=0
x=0 y=0
5．
#include <iostream.h>
class Point {
public:
Point( int x1=0, int y1=0) {
x=x1; y=y1; d=x*x+y*y;
}
void print(){
cout<<"x="<<x<<" y="<<y<<” dist=”<<d<<endl;
}
private:
int x, y, d;
};
void main()
{ Point p1(1),p2(2,3),*p;
p=&p1;
p->print();
p2.print();
}
答案： x=1 y=0 dist=1
x=2 y=3 dist=13
6．
#include <iostream.h>
class Base {
public:
Base(int n)
{ cout << "现在进入 Base 基类的构造函数\n";
i=n;
}
~Base( ) { cout <<"现在进入Base 基类的析构函数\n"; }
void showi( ) { cout << i << endl; }
private:
int i;
};
class Derive:public Base {
public :
Derive(int n, int m):Base(m)
{ cout << "现在进入 Derive 派生类的构造函数\n";
j=n;
}
~Derive( )
{ cout <<"现在进入 Derive 派生类的析构函数“<<endl; }
void showj( ) { cout << j << endl; }
private:
int j;
};
void main( )
{ Derive obj(30,40);
obj.showi( );
obj.showj( );
}
答案：现在进入 Base 基类的构造函数
现在进入 Derive 派生类的析构函数
40
30
现在进入 Derive 派生类的析构函数
现在进入Base 基类的析构函数
7.
#include <iostream.h>
class Time { char a[9];
public:
Time(int s=0, int m=0, int h=0) {
hours=h;
minutes=m;
seconds=s;
}
void show() {
cout<<"时间: "<<hours<<":"<<minutes<<":"<<seconds<<endl;
}
friend Time operator +(Time t1, Time t2);
private:
int hours;
int minutes;
int seconds;
};
Time operator +(Time t1, Time t2) {
Time temp;
temp.hours=t1.hours+t2.hours;
temp.minutes=t1.minutes+t2.minutes;
temp.seconds=t1.seconds+t2.seconds;
if(temp.seconds>60){
temp.seconds=temp.seconds-60;
temp.minutes++;
}
if(temp.minutes>60){
temp.minutes=temp.minutes-60;
temp.hours++;
}
if(temp.hours>=24) temp.hours=temp.hours-24;
return temp;
}
void main()
{ Time T, T1(20,23,21), T2(10,25,15), T3(5,10,15);
T=T1+T2;
T.show();
T=T+T3;
T.show();
}
答案： 时间: 12:48:30
时间: 3:58:35
8.
#include <iostream.h>
#include <string.h>
class Str{
public:
Str( char *pi ) {
p=new char[strlen(pi)+1];
strcpy(p,pi);
}
void show() {
cout<<"字符串: "<<p<<endl;
}
void operator ++();
private:
char *p;
};
void Str::operator ++() {
Str temp("\0");
temp.p=new char[2*strlen(this->p)+1];
strcpy(temp.p,this->p); strcat(temp.p,this->p);
this->p=new char[2*strlen(this->p)+1];
strcpy(this->p,temp.p);
}
void main()
{ Str T1("ABCDXYZ");
++T1;
T1.show();
}
答案：字符串: ABCDXYZABCDXYZ

9.
下面的程序定义一个类samp，有三类数据成员和一个构造函数和一个函数成员，填充程序缺少部分，使其变成完整的C++程序。
#include <iostream.h>
class Samp{
protected:
int b;.
public:
int c;
(1) (int n, int m ) //构造函数
{ a=n; (2) ; c=a+b;
}
int (3) (int i) //成员函数
{ if (i==1) return a;
else if(i==2) return b;
else return 0;
}
private:
int a;
};
void main ( )
{ Samp obj(20,30);
cout << (4) << endl; //输出20
cout << obj.getab(2) << endl; //输出30
cout << (5) << endl; //输出50
}
答案： ⑴. Samp ⑵. b=m; ⑶. getab ⑷. obj.getab(1) ⑸. obj.c

10.
下面的程序定义一个类samp，有三类数据成员和一个构造函数和一个函数成员，填充程序缺少部分，使其变成完整的C++程序。
#include <iostream.h>
class (1) {
public:
int c;
(2) (int n, int m ) //构造函数名
{ a=n; b=m; c=a+b;
}
int (3) (char ch) //成员函数名
{ switch(ch)
{ case 'a': return a; break;
case 'b': return b; break;
default : return 0;
}
}
private:
int a,b;
};
void main ( )
{ Myclass (4) (20,30); //定义对象
cout << obj.get('a') << endl; //输出20
cout << obj.get('b') << endl; //输出30
cout << (5) << endl; //输出50
}
答案： ⑴. Myclass ⑵. Myclass ⑶. get ⑷. obj ⑸. obj.c

11.
定义一个基类长方形Base，私有段有长a和宽b，公有段有构造函数，能显示长方形面积等。定义以该长方形为底面积的派生类长方体Cuboid，有高h，有构造函数，能显示长方体体积。在主函数中定义长方体对象，其长、宽、高分别为10，20，5，显示出长方体体积和长方形底面积。
#include <iostream.h>
class Base { //定义长方形
public:
Base (float a1=0, float b1=0)
{ (1)