C++ 测试题

一、 选择题（在A、B、C、D四个答案中选择一个正确的填入后面的括号中） 1．下面（ ）是对类ttt的声明。

A． void class ttt; B． class int ttt; C． class ttt( ); D． class ttt;

2． 用于类中虚成员函数说明的关键字是( )

A. public B. virtual C. protected D. private 3．下面是关于静态成员的说法，其中不正确的是（ ）。

A． 静态成员有类作用域，但与普通非静态成员有所不同 B． 静态函数没有this指针，同一个类的不同对象拥有相同的静态数据成员 C． 静态数据成员的初始化必须在类外进行 D． 静态函数同样可以访问非静态数据成员 4． 下面的说法中，不正确的一句是（ ）。

A．类的友元函数是类的特殊成员函数，它对所有的类成员、保护成员和私有成员享有完全访问特权。

B. 一个类的友元类中的成员函数都是这个类的友元函数

C. 适用于类成员函数和数据的访问控制同样适用于枚举和嵌套类

D. 与结构类似，类也可以互相嵌套，适用于嵌套结构的规则也适用于嵌套类 5． （ ）语言是面向对象的语言。

A. C B. Pascal C. Fortran D. C++ 6． C++风格的源文件包含的输入输出头文件为（）

A. stdio.h B. stdafx.h C. iostream.h D. stream.h 7． 与C语言printf(“Hello word\\n”) ；语句功能相同的C++语句是（）

A. cout>>”Hello word\\n” B. cin>>” Hello word\\n” C. cout<<” Hello word\\n” D. cin<<” Hello word\\n”

8． 在下面几个元素中，不是面向对象的要素的是（ ）；

A. 重载 B. 对象 C. 类 D. 继承 9． 对于int *pa[5];的描述，下面叙述正确的是（ ）；

A. pa是一个指向数组的指针，所指向的数组是5个int型元素； B. pa是一个指向某数组中第5个元素的指针，该元素是int型变量； C. pa是一个具有5个元素的指针数组，每个元素是一个int型指针； D. pa[5]表示某个数组的第5个元素的值。

10. 下面程序使用new与delete命令：

#include main( ) {

long *p , i; p=new long;

if(!p) {

cout<<”Allocation error\\n”; return 1; }

*p=1000; i=(long)p;

cout<<”Here is integer at p:”<<*p<<”\\n”; cout<<”Here is i: “<}

下面是对这段程序的叙述，其中正确的是（）。 A. 有错误，编译不能通过 B． 正确，执行结果为：1000 1000 C． 正确，但执行结果的第二个数值不定 D． 正确，执行结果的各个数值均不为1000

二、判断下列描述正确性，对者划√，错者划×（每小题2分）。

1． C++中标识符内的大小写字母是没有区别的。 2． 宏定义命令是分号结束的。 3． C++的程序中，对变量一定要先说明再使用，说明只要在使用之前就可以。 4． while循环语句的循环体至少执行一次。 5． 在C++中，所有函数在调用前都要说明。 6． 析构函数是一种函数体为空的成员函数。 7． 如果一个函数没有返回值时，定义时需要用void说明。 8.派生类是从基类派生出来的，它不能再生成新的派生类。

9.对象成员的表示与结构变量成员表示相同，使用运算符.或->。 10．构造函数和析构函数都可以重载，因为它们都是成员函数。 三、写出下面程序的输出结果。

1．#include

void main() { int a,b,c;

a=1,b=2,c=a+b+3;

cout<2. #include

void swap(int &x,int &y) {

int temp; temp=x; x=y; y=temp;

cout<<”x=”<void main() {

int a(5),b(9); swap(a,b);

cout<<”a=”<3. #include

class A {

public :

A( );

A(int i,int j); void print( );

private : int a,b; };

A::A( ) { a=b=0;

cout<<”Default constructor called.\\n”; }

A::A(int i,int j) { a=i; b=j;

cout<<”Constructor called.\\n”; }

void A::print( )

{ cout<<”a=”<void main( ) { A m,n(4,8); m.print( ); n.print( ); }

四、编程或程序填空。

1．在下划线处填上正确的语句并给出程序的输出结果（6分）。 #include #include ____(1)_______ class strA {

public:

strA(float,float,float);

______(2)________; ______(3)________;

public:

float a,b,c;

};

float strA::fun1( ) {

return a+b+c; }

strA::strA(float i,float j,float k) {

a=i; b=j; c=k; }

double strA::fun2( ) {

float s;

s=float((a+b+c)/2.0);

return sqrt(s*(s-a)*(s-b)*(s-c)); }

void maina( ) {

strA tri(3,4,5);

cout<2．编写分别可求两个整型、浮点型和双精度型数和的重载函数，并写主函数调用之； 3．使用引用作为函数参数，编写一个交换两变量值的函数，并写主函数调用之。

C++模拟试题2

一、 选择题（在A、B、C、D四个答案中选择一个正确的填入后面的括号中） 1. C++中，封装是借助于（ ）达到的。

E． 指针 B. 类 C. 数组 D. 函数 3． 宏定义由（）结束。

A． 分号 B. 句号 C. 新行 D. 冒号 3. 下面是关于一个类的友元的说法，其中不正确的是（ ）

A． 友元函数可以访问该类的私有数据成员 B． 友元的声明必须放在类的内部 C． 友元函数可以是类的成员函数

D． 类与类之间的友元关系不能被继承 4. C++中声明常量的关键字是（ ）。

A. const B. extern C. public D. enum 5. 关于动态联编的下列描述中，错误的是（ ）。

A. 动态联编是以虚函数为基础的

B. 动态联编时在运行时确定所调用的函数代码的

C. 动态联编调用函数操作是使用指向对象的指针或对象引用 D. 动态联编是在编译时确定操作函数的

6. 下面函数（ ）的表示方法说明它使用对象的引用作为参数。

A. test(pt *p) B. test(pt p) C. test(pt &p) D. test(const P) 7. 虚函数的调用（）。

A． 一定使用动态联编 B． 必须使用动态联编 C． 一定使用静态联编 D． 不一定使用动态联编

8． 关于C++与C语言的关系的描述中，错误的是（ ）；

A. C语言是C++的子集； B. C语言与C++是兼容的；

C．C++对C语言进行了一些改进； D. C++和C语言都是面向对象的。 9．重载函数在调用时选择的依据中，（ ）是错误的。

A. 参数个数 B. 参数类型 C. 函数名字 D. 函数类型

10. 下面的程序是关于函数承载的，假定A，B，C，D是它们可能的输出之一，其中正确的输出是（ ）。

A. 25 10 B. 20 10 C. 20 11.4 D. 20 14.076 源程序如下：

#include int Multiply(int n1, int n2) {

return n1*n2; }

float Multiply(int f1, float f2) {

return f1*f2; }

void main( ) {

int a1=10; int a2=2.5; float b1=2.55; float b2=5.52;

cout<二、判断下列描述正确性，对者划√，错者划×。

1． C++中数组元素的下标是从0开始，数组元素是连续存储在内存单元中的。 2． 函数一定要有函数体。

3．在说明语句int a(5),&b=a,*p=&a;中b的值和*p值是相等的。

4．for循环是只有可以确定的循环次数时才可使用，否则不能用for循环。

5. 在C++中，定义函数时必须给出函数的类型。 6. 对象引用作函数参数不如使用对象指针更方便。

7. 说明或定义对象时，类名前必须要加class关键字。 8． C++语言中，允许单一继承，不允许多重继承。

9．面向对象方法具有三大特性：封装性、继承性和继承性。 10．在共有继承中，派生类可以访问基类中的私有成员。

三、按要求写结果：

1． 计算下列表达式的值： (1) 已知：int i(10),j(5);

A. ++ i-j- -; B. i=i*=j; C. i=3/2*(j=3-2); (2) 已知：int a(5),b(3);计算下面表达式的值及a和b的值。

A. ! a && b++; B. a || b + 4 && a*b; C. a=1,b=2,a>b ? ++a: ++b;

2. 写出下面程序的输出结果。

(1) #include

void fun( ) {

static int n=25; n - -;

cout <<”n=”<void main( ) {

for(int i=0;i<2; i++) fun( ); }

(2) #include

class Base {

public :

void Setc(char a){c2=(c1=a)-32;} void Show( )

{ cout<private:

char c1,c2; };

void main( ) {

Base a,b;

a. Setc(„a‟); b. Setc(„b‟); a. Show( );

b. Show( );

}

(3) 定义类Tpoint如下：

class TPoint {

public:

TPoint(int x,int y){X=x;Y=y;} TPoint(TPoint &p);

~ TPoint( ){cout<<”destructor Called.\\n”;} int GetX( ){return X;} int GetY( ){return Y;} private : int X,Y; };

TPoint::TPoint(TPoint &p) {

X=p.X; Y=p.Y; }

并将其存入tpoint.h文件中，分析并写出下面主函数的执行结果： #include #include void main( ) {

TPoint P1(5,7); TPoint P2(P1);

cout<<”P2=”<四、编程或程序填空。

1． 在下划线处填上正确的语句成分，并编写一个测试主程序。

#include class Test {

public :

Test(int a,int b){ ___(1)______ } void show( ){ ____(2)_____ } private : int x,y;

};

2． 编写分别可计算2、3或4个int型数的和的重载函数，并写主函数调用之； 3. 设计一个类，使它具有一个求两个整数中较大者的成员函数以及输出成员函数，并写一个测试程序。

.3.