c面向对象复习题答案版要点.doc

一、 填空题
1.C++中有两种数据类型： ( char )和 ( int long )可以使用signed修饰符。
在C++中，用数组、指针、和( 引用 )作为函数参数，能够将参数值带回。
2.为了降低函数调用的时间开销，建议将小的调用频繁的函数定义为（内联函数 ），方法是在函数类型前加上（inline）关键字。
3.面向对象的程序设计有四大特征，它们是抽象、封装、( 继承 )、( 多态 )。
4.拷贝构造函数是在用一个对象初始化另一个对象时被调用，系统缺省的拷贝构造函数的工作方法是( 把对象的每个数据成员的值都复制到新建立的对象中)。
5.用new申请某一个类的动态对象数组时，在该类中必须能够匹配到(该类的)构造函数，否则应用程序会产生一个编译错误。
6.静态数据成员必须在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象( 共享 )。
7.在C++中，定义重载函数时，应至少使重载函数的参数个数或参数类型( 不同 )。
8.在C++中，虽然友元提供了类之间数据进行访问的一种方式，但它破坏了面向对象程序设计的( 封装 )特性。
9.预编译指令由三种，它们是：文件包含、 ( 宏定义 )和 ( 条件编译 )。
10.静态的成员函数没有隐含的 ( this )，所以，它们只能直接访问类的静态的数据成员。
11.在C++中，函数的参数有两种传递方式，它们是值传递和( 地址 )。
12.当非静态成员函数被调用时，该成员函数的( this )指向调用它的对象。
13.拷贝构造函数使用( 引用 )作为参数初始化创建中的对象。
14.在公有继承的情况下，基类数据成员在派生类中的访问权限( 不变 )。
15.在C++中，构造派生类对象时，总是先从( 基类 )的初始化开始的。
16.当需要统计程序中某个类创建对象的个数时，需要给该类定义（静态数据）成员。
17.在多个类之间有重复继承时，为避免被重复继承的基类数据成员在内存中有多个拷贝，应将该基类定义为（ 虚基类 ）。
18.在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为( 抽象类 )，定义该类至少具有一个( 纯虚函数 )。
19.在C++中构造一个对象时，其数据成员在构造函数中初始化。对于内嵌的对象、 ( 常量 )、 ( 引用 )数据成员需要在构造函数的成员初始化列表中初始化。
20.在类的定义中，说明为protected的数据成员称为保护成员。保护数据成员具有双重作用：对于其派生类而言， ( 可以访问 )；而对于其外部的程序而言， ( 不可以访问 )。
21.控制格式输出的
操纵符中，（setprecision）是设置数据精度的，（ hex ）是设置十六进制的。
22.如果s是int型变量，且s=6，则下面s%2+（s+1）%2表达式的值为__0_ _。
23．已知字母a的ASCII码为十进制数97，且设ch为字符型变量，则表达式ch=’a’+4’的值为_e_ __。
24．数组与函数参数联系密切，当用数组元素作函数参数时，这是属于值传递；当数组名作为参数时，这是属于 地址 传递，对形参的改变可影响到实参。
25．利用“对象名.成员变量”形式访问的对象成员仅限于被声明为 公有 的成员；若要访问其他成员变量，需要通过 公有 函数或友元函数函数。
26．一个__类____和__对象___的关系，正如基本数据类型与该类型的变量一个。
27．类成员的默认访问方式是_私有的_____.
28．一个类有_多个____个构造函数，有_一个____析构函数。
29．类的__静态___成员函数不能对类中的非静态成员进行默认访问。
30．如果说明类B是类A的友元类，则类B的所有成员函数都是类A的_友元函数 _____。
31．利用成员函数对二元运算符重载，其左操作数为　对象　　，右操作数为　　实际参数 　。
32．类有两种用法：一种是类的实例化，即生成类的__模板类____ ；另一种是通过__基类_____派生出新的类。
33．运算函数中的关键字是_ _ operator ____，它和运算符一起组成该运算符函数的函数名。
34．如果一个类中有一个或多个纯虚函数，则这个类称为_ _抽象类____。
35．文件的打开是通过使用类_ _ _对象_____的成员函数来实现的。
36．设所有变量均为整型，则表达式（e=2，f=5，e++，f++，e+f）的值为_9___。
37．已知c的ASCII码为十进制数99，设k为字符型变量，则表达式k=‘c’+1的值为___d_____。
38．函数的形参在未被调用之前 不被 分配空间，函数的形参的类型 要和实参的相同。
39．类的成员分为数据成员和_ _ _成员函数____。
40．类完成了面向对象程序设计的_抽象____特性。
41．构造函数是_对象_____被创建时自动执行，对象消失时自动执行的成员函数称为__析构_____对象
43．在继承机制下，当对象消亡时，编译系统先执行 派生类 的析构函数，然后才执行派生类中子对象类的析构函数，最后执行 基类 的析构函数。
44．类的__静态_____数据成员是类所有对象共享的成员。
45．友元函数__不是____类的成员函数。（是/不是）
46．如果类A继承了类B，则类A称为__派生类_____，类B称为__基类_____。
47．运算符重载后，原运算符的优先级和结合特性__不会___改变。（会/不会）
48．_纯虚函数_____是一个在基类中说明的虚函数，但未给出具体的实现，要求在其派生类实现。
49．文件的关闭是通过通过使用类________的成员函数________来实现的。（去掉）

二、选择题
1．面向对象的（ B ）是一种信息隐蔽技术，目的在于将对象的使用者与设计者分开。不允许使用者直接存取对象的属性，只能通过有限的接口与对象发生联系。
A．多态性 B．封装性 C．继承性 D．重用性
2．C++的合法注释是（ B ）。
A．/*This is a C program/* 　B．// This is a C program
C． “This is a C program” D．/*This is a C program//
3．关于C++和C语言的描述中，（ C ）是错误的？
A．C是C++的一个子集 B． C程序在C++环境可以运行
C． C++程序在C环境可以运行 D． C++是面向对象的而C是面向过程的
4．运算符 +、<=、=、% 中，优先级最低的运算符是（ C ）。
A. + B.<= C.= D.%
5．已知a=4，b=6，c=8，d=9，则“（a++，b>a++&&c>d）？++d：a<b” 值为（ D ）。
A．9 B．6 C．8 D．0
6．对while、do…while循环结构，下面说法正确的是（ B ）。
A．只是表达形式不同 B．do…while结构中的语句至少执行一次
C．while结构中的语句至少执行一次 D．条件成立时，它们有可能一次也不执行
7．对中断语句的说法下面不正确的是（ B ）。
A．用户可以指定中断的位置 B．用户可以指定转移的位置
C．break语句可以跳出本循环 D．continue语句可以结束本次循环
8．以下正确的说法是（D）。
A．用户若需要调用标准函数，调用前必须重新定义
B．用户可以直接调用所有标准库函数
C．用户可以定义和标准库函数重名的函数，但是在使用时调用的是系统库函数
D．用户可以通过文件包含命令将系统库函数包含到用户源文件中，然后调用系统库函数
9．下列哪个不是重载函数在调用时选择的依据（D ）。
A．参数类型 B．参数个数 C．函数类型 D．函数名
10．对数组名作函数的参数，下面描述正确的是（B）。
A．数组名作函数的参数，调用时将实参数组复制给形参数组
B．数组名作函数的参数，主调函数和被调函数共用一段存储单元
C．数组名作参数时，形参定义的数组长度不能省略
D．数组名作参数，不能改变主调函数中的数据
11．如果x是整型变量，则合法的形式是( D )。
A．＆(x+5) B．*x 　　　C．&*x 　　　 D．*&x
12．在定义一个共用体变量时，系统为其分配存储空间的原则是（B　　）。
A． 按所有成员需要的存储空间总和分配。B． 按成员中占存储空间最大者分配。
C． 按成员占存储空间最小者分配。 D．按第一个成员所需的存储空间分配。
13．下面（ B ）项是对构造函数和析构函数的正确定义。
A．void X::X(), void X::~X()
B．X::X(参数), X::~X()
C．X::X(参数), X::~X(参数)
D．void X::X(参数), void X::~X(参数)
14．拷贝构造函数具有的下列特点中，（ D ）是错误的。
A．  如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的
B．  拷贝构造函数只有一个参数，并且是该类对象的引用
C． 拷贝构造函数是一种成员函数
D． 拷贝构造函数的名字不能用类名
15．类的析构函数的作用是（ D ）。
A.一般成员函数 B.类的初始化 C.对象初始化 D.删除对象
16．下列对派生类的描述中，（ D ）是错误的。
A．一个派生类可以作为另一个派生类的基类
B．派生类至少有一个基类
C．派生类的成员除了它自己的成员外，还包含了它的基类成员
D．派生类中继承的基类成员的访问权限到派生类保持不变
17．继承具有（ B, C ），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。
A规律性 B.传递性 C.重复性 D.多样性
18．C++类体系中，能被派生类继承的是（ A,B,C ）。
A．构造函数 B．虚函数 C．析构函数 D．友元函数
19．下列关于动态联编的描述中，错误的是（D）。
A．动态联编是以虚函数为基础
B．动态联编是运行时确定所调用的函数代码的
C．动态联编调用函数操作是指向对象的指针或对象引用
D．动态联编是在编译时确定操作函数的
20．关于纯虚函数和抽象类的描述中，错误的是（ C ）。
A．纯虚函数是一种特殊的虚函数，它没有具体的实现
B．抽象类是指具有纯虚函数的类
C．一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类
D. 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出
21．C++源文件的扩展名为（ A ）。
A．cpp B．c C．txt D．exe
22．在C++语言中，（ A ）的陈述是正确的。
A．能使用关键字并区分大小写 B．能使用关键字并不区分大小写
C． 不能使用关键字并区分大小写 D．不能使用关键字并不区分大小写
23．运算符+、=、*、>=中，优先级最高的运算符是（ C ）。
A．+ B．= C．* D．>=
24．下列不合法的变量名为（A ）。
A．int B．int1 C．name_1 D．name0
25．已知x=43，ch=‘A’，y=0；则表达式（x>=y&&ch<’B’&&!y）的值是（ C ）。
A．0 B．语法错 C．1 D．“假”
A．语句for（i=0；；i++）表示无限循环 B．for（；；）表示无限循环
26．以下不正确的是（c）。?
C．for（）也表示无限循环 D．while（1）表示无限循环
27．在函数的返回值类型与返回值表达式的类型的描述中，错误的是（ B,D ）。
A． 函数返回值的类型是在定义函数时确定，在函数调用时是不能改变的
B． 函数返回值的类型就是返回值表达式的类型
C． 函数返回值表达式类型与返回值类型不同时，函数表达式类型应转换成返回值类型
D． 函数返回值类型决定了返回值表达式的类型
28．如果一个函数无返回值，定义时它的函数类型应是（C）。
A．任意 B．int C．void D．无
29．在C++语言中，关于参数默认值的描述正确的是（A,B）。
A．只能在函数定义时设置参数默认值
B．设置参数默认值时，应当从右向左设置
C．设置参数默认值时，应当全部设置
D．设置参数默认值后，调用函数不能再对参数赋值
30．若有以下定义，则说法错误的是( D )。
int a=100,*p=&a ;
A．声明变量p，其中*表示p是一个指针变量
B．变量p经初始化，获得变量a的地址
C．变量p只可以指向一个整形变量
D．变量p的值为100
31．列关于结构体的说法错误的是（D ）。
A．结构体是由用户自定义的一种数据类型
B．结构体中可设定若干个不同数据类型的成员
C．结构体中成员的数据类型可以是另一个已定义的结构体
D．在定义结构体时，可以为成员设置默认值
32．下列有关类的说法不正确的是（ C ）。
A．  对象是类的一个实例
B．  任何一个对象只能属于一个具体的类
C．  一个类只能有一个对象
D． 类与对象的关系和数据类型与变量的关系相似
33．（ C ）的功能是对象进行初始化。
A．析构函数 B. 数据成员 C.构造函数 D.静态成员函数
34．关于友元的描述中，（ A ）是错误的。
A．  友元函数是成员函数，它被说明在类体内
B．   友元函数可直接访问类中的私有成员
C．   友元函数破坏封装性，使用时尽量少用
D．   友元类中的所有成员函数都是友元函数
35．为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（A,B,C ）。
A.public B. protected C.private D. static
36．派生类的对象对它的（ A,B,D ）是可以访问的。
A．公有继承的基类的公有成员 B. 公有继承的基类的保护成员
C. 公有继承的基类的私有成员 D. 保护继承的基类的公有成员
37．多继承派生类构造函数构造对象时，（B ）被最先调用。
A．派生类自己的构造函数 B．虚基类的构造函数
C．非虚基类的构造函数 　 D．派生类中子对象类的构造函数
38．C++类体系中，不能被派生类继承的有（C ）。
A.构造函数 B.虚函数 C.静态成员函数 D.赋值操作函数
39．编译时的多态性可以通过使用(A,D )获得。
A．虚函数和指针 B．重载函数和析构函数
C．虚函数和对象 D．虚函数和引用
40．下列描述中，（ A ）是抽象类的特征。
A．可以说明虚函数 B．可以进行构造函数重载
C．可以定义友元函数 D．不能说明其对象

三、指出并改正下列程序段中的语法错误。
题目
答案
1.
float x=3.26f;
int &ref1=x;// float
1.类型不一致
2.
int d1=3, d2=2;
int * const dp=&d1;
dp=&d2;
*dp=5;
2.常指针
3. //Nums为已定义的类
Nums *fp;
fp=new int[4];
3.类型不一致
4.
void func(int first, int 2_secnd);
4.标识符得字母开头
5.
void Pixel::operator=(Pixel &p1, Pixel &p2);
5.“=”运算符重载函数返回类型不对
6.//Pixel有两个整型成员x和y
Pixel Pixel::operator+=(Pixle&p)const
{
x+=p.x;y+=p.y;
return *this;
}
6.在这里this是指向常量的常指针
2、指出并改正下列程序段中的语法错误。
题目
答案
1.
int x=13;
const int &ref=x;
ref=10;
1.常引用不能赋值了
2.
double *fp;
fp=new int(3);
2.类型不一致
3. void func( first, int secnd);

3. first不是类型说明
4. //Pixel有两个整型成员x和y,其拷//贝构造函数定义如下：
void Pixel(const Pixle& p);

4.不能有“void”
5.
friend Pixel & operator=(Pixel &p1, Pixel&p2);
5.不能定义友元函数，只能是成员函数。
6. //Pixel有两个整型成员x和y
Pixel Pixel::operator++(int)
{ Pixel temp; temp=*this;
x++;
y++;
return *this;temp;
}
6.
四、程序填空
1．编写函数将字符串按逆序存放。
#include<iostream.h>
#include<stdio.h>
#include<string.h>
void main()
{ int i,n;
char s[100],temp;

cout<<"input string:"<<endl;

（1） get(s);
n= （2） strlen(s);
for(i=0;i<n/2;i++)
{ temp=s[i];s[i]=s[n-i-1]; s[n-i-1]=temp; }
cout<<"Now,string:"<<endl;
puts(s);
}
2.下列程序定义了类Pixel，请完成前置++和后置++的运算符函数的定义。
class Pixel{
int x,y;
public:
Pixel(int xx=0,int yy=0){ x=xx; y=yy; }
Pixel operator ++();
Pixel operator ++(int);
void display();
};
Pixel Pixel::operator ++()
{

x++; y++;
return （3） *this
}
Pixel Pixel::operator ++(int)

{
（ 4 ）Pixel temp=*this;
x++; y++;

return （ 5 ） temp;
}
void Pixel::display()
{
cout<<"("<<x<<","<<y<<")"<<endl;
}
3. 根据给定的程序执行结果，将下列程序补充完整。
#include <iostream.h>
class Base{
public:
（ 6 ）Base（）{ cout<<” Delete Derived”<<lend; }
};

class Derived:public Base{
public:
（ 7 ）Derived （）{cout<<” Delete Base”<<lend; }

};
void main()
{

Base *p1= （ 8 ）new Derived ;
delete p1;
}
程序的执行结果如下：
Delete Derived
Delete Base

4．定义一个字符串类String，有两个私有数据成员：char* content和int len;要求
1）在构造函数中提示用户输入字符串，；
2) 用户能提取和显示字符串；（分别由两个函数完成）
3）实现对字符串中所有小写字母变成大写，并显示。
注意内存的分配与释放。
类定义的部分代码如下，请补充代码使类的定义完整。
#include <iostream.h>
#include <string>
#include <stdlib.h>
class String{
char* content;
int len;
public:

String();
~String(){ （ 1 ） delete content[]; }
void display();

void upper_str();
char* get_str() const{ （ 2 ） return content; }
};
String::String(){
char ch[50];//?
cout<<"enter a string: \n";
cin>>ch;

len=strlen(ch);
content= （ 3 ）new char[50];
if(!content)
{
cout<<" Memory allocation eror!";
exit(1);
}
strcpy(content,ch);
}
void String::display(){ cout<<content<<" have "<<len <<" characters."<<endl; }

void String::upper_str(){
for (int i=0;i<len;i++)
if （ 4 ）(’a’<= content[i]&& content[i] <=’z’)
content[i]= （ 5 ） content[i]+32;

}
5. 下列程序定义了类Point，请完成前置--和后置--的运算符函数的定义。
class Point{
float x,y;
public:
Point(float xx=0,float yy=0){ x=xx; y=yy; }
Point operator --();
Point operator --(int);
void display();
};
Point Point::operator --()
{
x--; y--;

return （ 6 ）*this;
}
Point Point::operator --(int)
{

（ 7 ） Point temp;temp=*this;
x--; y=y--;

（ 8 ）return temp;
}
void Point::display()
{
cout<<"("<<x<<","<<y<<")"<<endl;
}

6、程序填空，直接将答案写在空行上
1.
__#incolude <iostream.h>_//_1_
class A{ int a;
public: A(int i){a=i;}
void print(){cout<<a<<endl;}
};
class B{ A obj_a;

int b;
public:
_B(int i): obj_a (i)_ _ { b=i; }

void print();
};
__void B::print()_//3_{
obj_a.print(); cout<<b<<endl;
}
int main( )
{ B obj_b(3,4);
obj_b.print(); return 0; }
2.
#include <iostream.h>
5
#include <math.h>
class Complex{
double real,image;
public:
Complex(double r=0,double i=0) { real=r; image=i; };
4 friend ostream & operator <<( ostream &, Complex &) ;
};
5 ostream & operator <<( ostream & output , Complex & obj) ;
{ output << obj.real << obj.image;
6 return output ;

}
int main()
4
{
Complex c;
cout<<c;
return 0;
}//重载<<

五、写出程序的运行结果
1.
#include <iostream.h>
int main(void)
{
char str[]="configuration";
char *p=str;
cout<<p<<endl;
for(int i=0;i<sizeof(str);i=i+2)
cout<<str[i];
cout<<endl;//字符c的ASCII码是99
for(i=0;i<4;i++)
cout<<*p+i<<' ';
cout<<endl;
return 0;
}

第1题的运行结果如下：
configuration
cniuain
cdef

2.
# include<iostream.h>
class Node
{
public:
int data;
Node *next;
Node(int d,Node * q=0)
{ data=d;next=q; }
第2题程序运行结果：
67->45->23->
};

int main()
{
int n;
Node * p;
Node * q=0;
while (cin>>n){
p=new Node(n,q);
q=p;
}
for(p=q;p;p=p->next)
cout<<p->data<<"->";
cout<<"*\n";
return 0;
}//假定，输入如下3个数据：23 45 67↙
3.
#include <iostream.h>
class ConstTest{
int m1,m2;
public:
ConstTest(int x,int y){ m1=x;m2=y;}
void print(){cout<<m1<<","<<m2<<endl;}
void print() const;
};
void ConstTest::print() const
{
cout<<"const fun: "<<m1+m2<<endl;
}
int main()
{
ConstTest a(6,9);
a.print();
const ConstTest b(2,5);
第3题程序运行结果：
6, 9
const fun: 7

b.print();
return 0;

}
4.
#include <iostream.h>
class Plane{
protected:
int x,y;
public:
Plane(int a,int b){x=a;y=b;}
virtual void print()
{cout<<'('<<x<<','<<y<<')'<<endl;}
virtual void increase(int d);
};
class Solid:public Plane{
int z;
public:
Solid(int a,int b,int c):Plane(a,b){z=c;}
void print()
{cout<<'('<<x<<','<<y<<','<<z<<')'<<endl;}
void increase(int d);
};
void Plane::increase(int d){x+=d;y+=d;}
void Solid::increase(int d){x+=d;y+=d;z+=d;}
//接右边的代码
int main()
{
Plane d1(3,6);
Solid d2(2,7,9);
Plane *ptr;
ptr=&d1; ptr->print();

ptr=&d2; ptr->print();
ptr->increase(4);
ptr->print();
d2.print ();
(3, 6)
(2, 7, 9)
(6,11,13)
(6,11,13)

}
第4题

运行结果：
(3,6)
(2,7)
(6,11)
(6,11,9)

5.去掉上题（即第4小题）程序中的 “ virtual”关键字，运行结果如何？ (8 分)
第5题
运行结果：
6.
#include <iostream.h>
class Count{
static int count;
public:
Count(){count++;}
static int Getc(){return count;}
~Count(){count--;}
};
int Count::count=100;
int main(void)
{
Count c1,c2;
cout<<Count::Getc()<<endl;
{
Count c[3];
cout<<Count::Getc()<<endl;
}
cout<<Count::Getc()<<endl;
return 0;
}

第6题102
105
102
的运行结果：

1.
#include <iostream.h>
void main(void){
char string[]="fortunate ";
char *p=string;
cout<<string<<endl;
cout<<*p<<*(p+2)<<*(p+4)<<*(p+6)<<endl;
for(int i=1; i<sizeof(string); i+=2)
cout<<string[i];
}

2.
#include<iostream.h>
void main() {
int a;
cout<<"please input a number:";
cin>>a;
switch(a%2)
{
case 0: cout<<"a是偶数"<<endl;
default: cout<<"a是奇数"<<endl;
}
a=a/4;
cout<<a<<endl;
}如果输入数为6，则输出结果是什么？ 1

4. ( 3 分)
#include<iostream.h>
class Point
{ int x,y;
public: Point(int a=0,int b=0) {x=a; y=b;}
void move(int xoffset,int yoffset)
{x+=xoffset; y+=yoffset;}
int getx() {return x;}
int gety() {return y;}
};
class Rectangle:public Point
{ int length,width;
public:
Rectangle(int x,int y,int l,int w):Point(x,y)
{ length=l;width=w;}
int getlength(){return length;}
int getwidth(){return width;}
};
void main()
{
Rectangle r(0,0,4,9);
r.move(33,66);
cout<<r.getx()<<","<<r.gety()<<","<<r.getlength()<<","<<r.getwidth()<<endl;
}
5.
#include <iostream.h>
class Base
{ public:
virtual void show()
{cout<<"Base::show()"<<endl;}
};
class Derived1: public Base
{
public:void show()
{cout<<"Derived1::show()"<<endl;}
};

class Derived2: public Derived1
{
public:void show()
{cout<<"Derived2::show()"<<endl;}
};
void main()
{
Base b;

Derived1 d1;
Derived2 d2;
Base *ptr[3]={&b,&d1,&d2};
for (int i=0;i<3;i++)
ptr[i]->show();
}
Base::show()
Derived1::show()
Derived2::show()

6.去掉上题（即第5小题）程序中的 “ virtual”关键字，运行结果如何？
Base::show()
Base::show()
Base::sho