C++考试重点.doc

C＋＋考试重点

一、选择题
1.关于函数重载：A
A.两个或两个以上的函数取相同的函数名，但形参的个数或类型不同
B.两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同
C两个以上的函数名字不同，但形参的个数或类型相同
. D.两个以上的函数取相同的函数名，并且函数的返回类型相同
2. 关于引用：
A. 每一个引用都是其所引用对象的别名,因此必须初始化V
B . 形式上针对引用的操作实际上作用于它所引用的对象V
C . 一旦定义了引用，一切针对其所引用对象的操作只能通过该引用间接进行X
D. 不需要单独为引用分配存储空间V
3. 关于封装，B
A . 通过封装，对象的全部属性和操作结合在一起，形成一个整体
B. 通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C.通过封装，每个对象都成为相对独立的实体
D. 通过封装，对象的属性都是不可见的
4. 判断
A派生类的对象可以赋给基类的对象 V
B.派生类的对象可以初始化基类的引用 V
C.派生类的对象可以直接访问基类中的成员 X
D .派生类的对象的地址可以赋给指向基类的指针V
5.对于类定义
Class {
public:
virtual void funy( ){ }
void funx( ){ }
}
class B:public m{
public:
void funy( ){cout<<〃class B func 1〃<<end1;}
virtual void funx( ){cout<<〃class B func 2〃<<end1;}
};
判断下列说法是否正确？C对
A. M::funx( )和B::funy( )都是虚函数
Ｂ、M::funx( )和B::funy( )都不是虚函数
Ｃ、 B::funy( )是虚函数，而M::funx( )不是虚函数 V
Ｄ、B::funy( )不是虚函数，而M::funx( )是虚函数
6 对于char* kk[7];的描述，（ ）是正确的。D
A. kk是一个指向数组的指针，所指向的数组是7个char型元素；
B. kk是一个指向某个数组中第7个元素的指针，该元素是char型变量；
C. kk[7]表示某个数组的第7个元素的值；
D. kk是一个具有7个元素的指针数组，每个元素是一个char型指针；
7. 关于静态数据成员：
A.说明静态数据成员时前边要加修饰符static;V
B.静态数据成员要在类体外进行初始化；X
、 C. 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；V
D. 静态数据成员不是所有对象所共用的。V
8.关于函数模板：
A. 函数模板也是一个具体类型的函数X
B . 函数模板的类型参数与函数的参数是同一个概念X
C . 通过使用不同的类型参数，函数模板可以生成不同类型的函数V
D 用函数模板定义的函数没有类型X

9. 下列哪种调用方式是引用调用。C
A. 形参和实参都是变量 B.形参是指针，实参是地址值
C. 形参是引用，实参是变量 D.形参是变量，实参是地址值

填空题：
1. 为了提高程序的运行速度，可将不太复杂的功能用函数实现，此函数应选择（ 内联 ）函数。
2.面向对象方法的多态性是指（ 针对一消息，不同的对象可以以适合自身的方式加以响应 ）。
3. 当一个成员函数被调用时，该成员函数的( this 指针 ) 指向调用它的对象。
4.在公有继承的情况下，基类数据成员在派生类中的访问权限是什么？
保持不变，派生类会继承基类的成员函数和成员变量，在公有继承的情况下，派生类不改变基类成员的访问权限。
5． 静态数据成员在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象 ( 共享 ) 。
6． 构造函数与析构函数除功能不同外，在定义形式上，它们的区别还包括构造函数名与类名相同，而析构函数名是在类名前加一个~、 析构函数__没有___（有/没有）参数 、 析构函数___可以__（可以/不可以）定义为虚函数 。
7.在类作用域中能够直接使用该类的（任何 ）成员名进行访问。

8． 面向对象的程序设计有四大特征，它们是？
1.抽象：
　　抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。比如，我们要设计一个学生成绩管理系统，考察学生这个对象时，我们只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象是指任何一个明确定义功能的操作都可被使用者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。数据抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这些操作修改和观察。
2.继承：　　继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。这也体现了大自然中一般与特殊的关系。继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
3.封装：
　　封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐藏。事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。
4. 多态性：
　　多态性是指允许不同类的对象对同一消息作出响应。比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。又比如，同样的选择编辑-粘贴操作，在字处理程序和绘图程序中有不同的效果。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
9． 动态联编要满足哪两个条件？
调用的函数是虚函数、用指针或引用调用虚函数
　10． 在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为 ( 抽象类 ) ，定义该类至少具有一个( 纯虚函数 ) 。
　11． 在C++类中，const关键字可以修饰对象和成员函数，const对象不能( 调用类中的非const成员函数 ) ，const成员函数不能 ( 修改类的private数据成员 ) 。
　12． 举出C++中两种代码复用的方式： ( 继承 ) 、 ( 复用 ) 。

假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（ x.a ）。；如果是静态成员，直接AA::a，对象为 x.a，指针访问为 x->a
14. 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ int AA::a() ）。
15. 类的构造函数是在定义该类的一个( 对象 )时被自动调用执行的。
16. 假定一个类AB只含有一个整型数据成员a，用户为该类定义的带参构造函数可以写为( AB(int aa=0) {a=aa;} )。

1 7. 对于任一个类，用户所能定义的构造函数的个数至多为( 任意个 )。
18. 对类对象成员的初始化是通过构造函数中给出的( 初始化表或函数体 )实现的。
19. 被非静态成员函数访问的类的数据成员可以是( 静态数据成员）
20. 引入友元的主要目的是（ 提高程序的效率和灵活性 ）。。

判断：
1． 构造函数不是类的成员函数X
C++中,成员函数包括构造函数、析构函数、私有函数和公有函数四种
2． 引用一旦初始化，就维系在一定目标上，任何对该引用的赋值都不能使引用维系在其他目标上。V
3． 函数重载的目的是提高运行效率。X
使用方便，提高可读性

4． 类的静态数据成员需要在定义每个类的对象时进行初始化X

5． 函数的参数和返回值类型可以是简单数据类型，也可以是指针、引用、数组和类。X

6．在基类中被说明为虚函数的类的成员函数必须在每个派生类中说明为虚函数，才能具有多态的特征。X
7． 在类定义时，并不给类分配存储实间，因此类定义中不允许对其数据成员直接进行初始化。V
8．C++中使用了新的注释符（//），C语言中注释符（/*…*/）不能在C++中使用。（X）
9．返回值类型、参数个数和类型都相同的函数也可以重载。（X）
10. 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。（X　）
错误 不能存取或修改该类的static成员和const成员
11. 对象数组的元素可以是不同类的对象。（X　）
12. Const int *p说明了p是指向整型的常量指针。（V　）
。

阅读程序，写出运行结果

#include <iostream>
class AA{ public: AA(int i,int j)
{A=i;B=j;cout<<"Constructor\n";}
AA(AA &obj)
{A=obj.A+10;B=obj.B+50;cout<<"Copy_Constructor\n";}
~AA() {cout<<"Destructor\n";}
void print()
{cout<<"A="<<A<<",B="<<B<<endl; }
private: int A,B;
};
void main(){
AA a1(5,8); AA a5(a1); a5.print(); AA *pa=new AA(4,6);
pa->print(); delete pa;

结果：Constructor
Copy_Constructor
A=15,B=58
Constructor
A=4,B=6
Destructor

#include<iostream>
Class T
{public:
T(int x){a=x;b+=x;};
static void display(T c)
{cout<<”a=”<<c.a<<’\t’<<”b=”<<c.b<<endl1;}
private:
int a;
static int b;
};
int T::b=4;
void main()
{T A(8),B(4);
T::display(A);
T::display(B);
}

解答：A=8 B=16
A=4 B=16

#include <iostream>
Class CC1
{public:CC1(int i) {cout<<”调用CC1的构造函数：”<<i<<endl;}

};
Class CC5
{public:CC5(int j) {cout<<”调用CC5的构造函数:’<<j<<endl;}
};
Class A: public CC5,public CC1
{public:
A(int a,int b,int c,int d):CC1(c),CC5(b),b5(a),b1(d)
{cout<<”调用A的构造函数:”<<a+b+c+d<<endl;}
Private :CC1 b1;
CC5b5;
};
Void main()
{A obj(2,3,7,2);}
结果：调用CC5的构造函数:3
调用CC1的构造函数：7
调用CC1的构造函数：2
调用CC5的构造函数:2
调用A的构造函数:14

阅读程序，回答问题：
10． 分析下列程序中的访问权限，并回答下列问题
#inLlude <iostreMm>
class M
{ public: void f1( ) {}
M( ){}
proteLted: int j1;
private: int i1;
};

class N: proteLted M
{puNliL: void f5( ){}
N( ) {}
proteLted: int j5;
privMte: int i5;
};
class L: proteLted N
{public: void f3( ) {}
L( ) {}
proteLted: int j3;
private: int i3;
};
(1)派生类N中成员函数f5()能否访问基类M中的成员f1(),i1,j1;
答案：1(),i1可以访问j1不可以 private是任何继承方式都不能访问的
(2)派生类N的对象N能否访问基类M中的成员f1(),i1,j1;
答案：f1()可以访问，i1只能在内部直接访问不能被对象访问，j1不能
（3）派生类C中成员函数f3()能否访问基类N中的成员f5(),i5,j5; 能否访问基类M中的成员f1(),i1,j1;
答案：f5(),j5可以访问 f1(),i5可以访问 j1不行
（4） 派生类C的对象c能否访问基类N中的成员f5(),i5,j5; 能否访问基类M中的成员f1(),i1,j1;
答案：f5()可以 ,j5不行, f1可以, i1 j1不行

百度原题：
#include<iostream.h>
class A
{public:
void f1();
protected:
int j1;
private:
int i1;
};
classB:public A
{ public:
void f2();
protected:
int j2;
private:
int i2;
};
class C:public B
{public:
void f3();
};
回答下列问题：
1．派生类B中成员函数f2()能否访问基类A中的成员：f1(),i1 和j1？
2．派生类B的对象b1能否访问基类A中的成员：f1(),i1 和j1？
3．派生类C中成员函数f3()能否访问直接基类B中的成员：f2() 和j2？能否访问间接基类A中的成员：f1(),i1 和j1？
4．派生类C的对象c1能否访问直接基类B中的成员：f2() 和j2？能否访问间接基类A中的成员：f1(),i1 和j1？
1.f1(),i1可以访问j1不可以 private是任何继承方式都不能访问的
2.f1()可以访问，i1只能在内部直接访问不能被对象访问，j1不能
3.f2(),j2可以访问 f1(),i1可以访问 j1不行
4.f2()可以 j2不行 f1可以,i1，j1不行

1 设计一个立方体类Nox，它能计算并输出立方体的体积和表面积。
第一种代码：#include <iostream>
using namespace std;
class Box
{
public:
Box(double t)
{
a = t;
volume = 0.0;
area = 0.0;
}
double seta(double i)
{
a = i;
return a;
}
double getvolume()
{
volume = a * a*a;
return volume;
}
double getarea()
{
area = 6 * a*a;
return area;
}
void disp()
{
getvolume();
getarea();
cout << "=>体积" << volume << ",表面积" << area << endl;
}
private:
double a, volume, area;
};
int main()
{
Box obj1(3.1);
cout << "obj1";
obj1.disp();
Box obj2(5.6);
cout << "obj2";
obj2.disp();
system("PAUSE");
}
第二种代码：
#include <iostream>
using namespace std;
class Box {
private:
double length;
double volume;
double area;
public:
Box(double l) {
length = l;
volume = 0.0;
area = 0.0;
}
double getVolume() { return length * length * length; }
double getArea() { return length * length * 6; }
void show() { volume = getVolume(); area = getArea(); cout << "立方体的体积：" << volume << ",表面积：" << area << endl; }
};
int main() {
int length = 0;
cout << "请输入立方体的边长:";
cin >> length;
Box box(length);
box.show();
getchar();
system("PAUSE");
return 0;
}
第三种代码：
#include <iostream.h>
class Nox
{
public:
Nox(double t )
{
a=t;
volume=0.0;
area=0.0;
}
double seta(double i )
{
a=i;
return a;
}
double getvolume()
{
volume=a*a*a;
return volume;
}
double getarea()
{
area=6*a*a;
return area;
}
void disp()
{
getvolume();
getarea();
cout<<"=>体积"<<volume<<",表面积"<<area<<endl;
}
private:
double a,volume,area;
};
void main()
{
Nox obj1(3.1);
cout<<"obj1";
obj1.disp();
Nox obj2(5.6);
cout<<"obj2";
obj2.disp();
}
2． 编程实现抽象类Employee，派生类Mnger和HourlyWorker，Employee有数据成员姓名nMme和工号ID，MMnger有数据成员sMl，代表经理的月工资，HourlyWorker有wMge和hours，分别代表钟点工的每小时的工资数和月工作时数，定义的所有类中必须包含构造函数、析构函数、修改和获取所有数据成员的成员函数,以及虚函数来计算职员的工资、输出职员的姓名nMme和工号ID。

#include <string>
#include <iostream>
using namespace std;
class Employee {
public: Employee() {};
virtual void gongzi() { cout << "no"; }
void xianshi() { cout << "no"; }
string name; string id;
~Employee() {};
};
class Manger :public Employee
{
public: Manger(string s1, string s2) { name = s1; id = s2; }
void gongzi() {
cout << name << "的月工资为：" << sal << endl;
cout << endl;
}
void xianshi() {
cout << "经理的姓名为：" << name << endl;
cout << "经理的ID为：" << id << endl;
}
void set() { cout << "请修改经理的月工资为："; cin >> sal; cout << endl; }
~Manger() {}; private: int sal;
};
class HourlyWorker :public Employee
{
public:HourlyWorker(string s1, string s2) { name = s1; id = s2; }
void gongzi() { cout << name << "的月工资为：" << wage * hours << endl; }
void xianshi() {
cout << "钟点工的姓名为：" << name << endl;
cout << "钟点工的ID为：" << id << endl;
} void set() {
cout << "请输入钟点工每小时的工资数：";
cin >> wage; cout << endl;
cout << "请输入钟点工月工作时数：";
cin >> hours; cout << endl;
}
~HourlyWorker() {}; private: int wage; int hours;
}; void fun(Employee *p) {
p->gongzi();
} void main() {
Manger zhangye("zhangye", "200913030135");
HourlyWorker zjy("zhangjunyu", "200913030104");
zhangye.xianshi(); zhangye.set();
fun(&zhangye);
zjy.xianshi();
zjy.set();
fun(&zjy);
}

在用class定义一个类时，数据成员和成员函数的默认访问权限是 ?；私有
（3）含有纯虚函数的类称作？；抽象类
（4）已知intDNL(int n){return n + n;}和longDNL(long n){return n +n;}
是一个函数模板的两个实例，则该函数模板的定义为：？
Template<class T> TDBL(T n){return n+n;}
在下面程序的横线处填上适当的语句，使该程序执行结果为121.
#include
class MyClass
{ 　puNlic:
　　MyClass(int a）{x = M;}
　　MyClass(int x){this.x=x;};int GetNum(){return x;};
//取x值
　　private
　　int x;
};
int mMan()
{ 　MyClass my(121);
　　cout<<MY.GETNUM()<<ENDL;
　　return 0;
}

下面程序的打印结果是?
#include <iostream>
int f(int);
int main()
{ 　int i;
　　for(i=0;i<4;i++)
　　cout<<f(i)<<"";
　　return0; }
int f(int i)
{ 　static int k=1;
　　for(;i>0;i- -)
　　k + = i;
return k;
}
打印 1111

#include <iostream.h>
class Point {
int x,y;
puNlic:
Point(int x1=0, int y1=0) :x(x1), y(y1) {
cout<<"Point:"<<x<<' '<<y<<'\n'; }
~Point() {cout<<"Point destructor!\n"; }
};
class Circle { Point center; //圆心位置
int radius; //半径
puNlic:
Circle(int cx,int cy, int r):center(cx,cy),rMdius(r) {
cout<<"Circle radius:"<<radius<<'\n';
}
~Circle() {cout<<"Circle destructor!\n";}
};
void main()
{
Circle c(3,4,4);
}
打印：
Point:3 4
Circle radius:4
２ #include <iostream.h>
Class NMSE1 {
puNlic:NMSE1(int i) {cout<<”调用NMSE1的构造函数：”<<i<<endl;}
};
Class CC5 {
puNlic:CC5(int j) {cout<<”调用CC5的构造函数:’<<j<<endl;}
};
Class M: puNlic NMSE1,puNlic CC5
{puNlic:
M(int M,int N,int c,int d):NMSE1(c),CC5(N),N1(d),N5(M)
{cout<<”调用M的构造函数:”<<M+N+c+d<<endl;}
PrivMte :CC5 N5;
NMSE1 N1;};
Void mMin() {M oNj(1,5,3,4);}
打印：
调用NMSE1的构造函数：3
调用CC5的构造函数:5
调用CC5的构造函数:1
调用NMSE1的构造函数：4
调用M的构造函数:13
３ #include "iostreMm.h"
ClMss NclMss
{puNlic:
Nclass(int i,int j) {x=i;y=j;}
virtual int fun(){return 0;}
protected:
int x,y;};
class Iclass:puNlic Nclass
{puNlic:
Iclass(int i,int j,int k):Nclass(i,j){z=k;}
int fun(){return (x+y+z)/3;}
privMte:
int z;};
void main()
{Iclass oNj(3,6,8);
Nclass p1=oNj;
cout<<p1.fun()<<endl;
Nclass &p5=oNj;
cout<<p5.fun()<<endl;
cout<<p5.Nclass::fun()<<endl;
NclMss *p3=&oNj;
cout<<p3->fun()<<endl;
}
打印
0
5
0
5

#include <iostreMm.h>
clMss MM{ puNlic: MM(int i,int j)
{M=i;N=j;cout<<"Constructor\n";}
MM(MM &oNj)
{M=oNj.M+10;N=oNj.N+50;cout<<"Copy_Constructor\n";}
~MM() {cout<<"Destructor\n";}
void print()
{cout<<"M="<<M<<",N="<<N<<endl; }
privMte: int M,N; };
void mMin(){
MM M1(5,3); MM M5(M1); M5.print(); MM *pM=new MM(4,6);
pM->print(); delete pM;
}
打印
Constructor
Copy_Constructor
M=15,N=53
Constructor
M=4,N=6
Destructor
11