第二部分 C++ 类、函数和指针
1、有关类的说法不正确的是 D
A）类是一种用户自定义的数据类型.
B）只有类中的成员函数才能存取类中的私有成员.
C）在类中，如果不做特别说明，所指的数据均为私有类型.
D）在类中，如果不做特别说明,所指的成员函数均为公有类型
2、类A是类B的友元,类B是类C的友元,则____ D ______是正确的.
A ) 类B是类A的友元 B ) 类C是类A的友元
C ) 类A是类C的友元 D ) 以上都不对
3、有下面类的说明，有错误的语句是____ A ______
class X
{
A ) int a=2;
B ) X( ) ;
public:
C ) X(int val ) :
D ) ~X( ) ;
};
4、有关析构函数的说法不正确的是_____ B _____
A ) 析构函数有且仅有一个
B ) 析构函数和构造函数一样可以有形参
C ) 析构函数的功能是用来释放一个对象
D ) 析构函数无任何函数类型
5、已知一个类X, _____C_____是定义指向类X成员函数的指针,假设类有3个公有成员: void f1(int ) , void f2(int ) 和int a.
A ) X*P B ) int X::*pc=&X::a C ) void(X::*pa ) ( ) D ) X*p[10]
6、下列的各类函数中，____C______不是类的成员函数
A ) 构造函数 B ) 析构函数 C ) 友元函数 D ) 拷贝构造函数
7、下列定义中，x是一个类, ______B____是定义指向对象数组的指针p.
A ) x *p[4] B ) x (*p ) [4] C ) (x* ) p[4] D ) x *p[]
8、已知p是一个指向类X数据成员m的指针,s是类X的一个对象如果要给m赋值为3, __ C _____是正确的.
A ) s.p=3 B ) s - >p=3 C ) s.*p=3 D ) *s.p=3
9、已知f1(int ) 是类X的公有成员函数,p是指向成员f1( ) 的指针，采用它赋值, ____ B ______是正确的.
A ) p=f1 B ) p=X::f1 C ) p=x::f1 D ) p=f1( )
10、已知类X中的一个成员函数说明如下:
Void Set(x &a ) ;
其中,X &a的含义是______ C ____.
A ) 指向类X的指针为a
B ) 将a的地址赋给变量Set
C ) a是类X的对象引用，用来做为Set( ) 的形参
D ) 变量X是a按位相与作为函数Set( ) 的参数
11、一个类的友元函数能够访问该类的______ D ____.
A ) 私有成员 B ) 保护成员 C ) 公有成员 D ) 所有成员
12、有关类和对象的说法不正确的是______ B ____.
A ) 对象是类的一个实例
B ) 一个类只能有一个对象
C ) 任何一个对象只能属于一个具体的类
D ) 类与对象的关系和数据类型和变量的关系相似
13、下列静态数据成员的特性中，_____ D _____是错误的.
A ) 说明静态数据成员时前边要加关键字static来修饰
B ) 静态数据成员在类体外进行初始化
C ) 引用静态数据成员时,要在静态数据成员名前加<类名>和作用域运算符
D ) 静态数据成员不是所有对象所共有的
14、类模板的使用实际上是类模板实例化成一个具体的_____ A _____.
A ) 类 B ) 对象 C ) 函数 D ) 模板类
15、通常拷贝构造函数的参数表是_____ C _____.
A ) 某个对象名 B ) 某个对象的成员名
C ) 某个对象的引用名 D ) 某个对象的指针名
16、关于常数据成员的说法不正确的是_____ D _____.
A ) 常数据成员的定义形式与一般常量的定义形式相同，只不过常数据成员的定义必须出现在类体中.
B ) 常数据成员必须进行初始化,并且不能被更新
C ) 常数据成员通过构造函数的成员初始化列表进行初始化
D ) 常数据成员可以在定义时直接初始化
17、已知X类.则当程序执行到语句
X array[3];
时,调用了____D______次构造函数.
A ) 0 B ) 1 C ) 2 D ) 3
18、类模板的模板参数_____ D _____.
A ) 只可作为数据成员的类型 B ) 只可作为成员函数的返回类型
C ) 只可作为成员函数的参数类型 D ) 以上三者皆可
19、下列_______D___不是构造函数的特征
A ) 构造函数的函数名与类名相同 B ) 构造函数可以重载
C ) 构造函数可以设置默认参数 D ) 构造函数必须指定类型说明
20、下列程序中说明的公有成员是______ D ____.
class Location{
int X;
public:
void init(int initX,int initY ) ;
private:
int Y;
public:
int GetX( ) ;
int GetY( ) ;
}
A ) X
B ) init(int initX,int initY )
C ) GetX( ) ,GetY( )
D ) B ) 和C ) 都是
21、类定义的内容允许被其他对象无限制地存取是______ C ____.
A ) private 部分 B ) protected 部分
C ) public 部分 D ) 以上都不对
22、关于下面程度段说法正确的是_____ A _____.
class X
{
private:
int n;
punblic:
X(X& ) ;
}
X::X(X&x )
{n=x.n}
X obj1,obj2;
obj2(obj1 ) ;
A ) 语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2
B ) 语句obj2（obj1）；的功能是用对象obj2初始化具有相同类类型的对象obj1
C ) X(X&x ) 也可以不使用引用参数而仍然是拷贝构造函数
D ) X(X&x ) 不能访问对象的私有成员
23、this指针是C++实现_____B_____的一种机制.
A ) 抽象 B ) 封装 C ) 继承 D ) 重载
24、下面程序段中是内联函数的是____ C ______
chass location
{
private:
int x ,y;
public:
void init(int initx,int inity )
{ x=initx;
y=inity;
}
int getx( ) {return x;}
int gety( ) ;
};
inline int location::gety( ) {return y;}
A ) init (int initx,int inity ) B ) getx( ) ,gety( ) C ) A ) 和B）都是 D ) A）和getx( )
25、关于对象成员的构造函数的调用顺序，说法正确的是_____ C _____
A）与它们在成员初始化列表中给出的顺序相同
B）与析构函数的调用顺序相同
C）与它们在类中说明顺序相同
D）以上说法都不对
26、类模板trmplate<class T>classX{……},其中，友元函数f( ) 成为该类模板实例化的每个模板类的友元，则其说明应为_____ A _____.
A ) friend void f( )
B ) friend void f(X<T>& ) ;
C ) friend void A::f( ) ;
D ) friend void C<T>::f(X<T>& ) ;
27、运算符—>*的功能是（ A ）
A ) 用来表示指向对象指针对指向类成员指针的操作
B ) 用来表示对象类成员的操作
C ) 用来表示指向对象指针对类成员的操作
D ) 用来表示对象指向类成员指针的操作
28、下列说明中const char * ptr; ptr 应该是 C
A ) 指向字符的指针 B ) 指向字符的常量指针
C ) 指向字符串常量的指针 D）指向字符串的常量指针
29、下面关于友元的描述中，错误的是（ D ）
A ) 友元函数可以访问该类的私有数据成员
B ) 一个类的友元类中的成员函数都是这个类的友元函数
C ) 友元可以提高程序的运行效率
D ) 类与类之间的友元关系可以继承
30、一个（ C ）允许拥护为类定义一种模式，使得类中的某些数据成员、某些成员函数的参数和返回值可以取任意数据类型
A） 函数模板 B）模板函数
C） 类模板 D）模板类
31、有关构造函数说法不正确的是（ D ）
A ) 构造函数的名字和类的名字一样
B） 在创建对象时，系统自动调用构造函数
C ) 构造函数无任何函数类型
D ) 构造函数有且只有一个
32、下面对模板的声明，正确的是（ C ）
A ) template<T> B ) template<class T1,T2>
C ) template<classT1,classT2> D）template<classT1;classT2>
33、 ( D ) 是析构函数的特征
A） 析构函数可以有一个或多个参数 B） 析构函数定义只能在类体内
C） 析构函数名与类名不同 D）一个类中只能定义一个析构函数
34、下列关于构造函数的描述中,错误的是( C )
A ) 构造函数可以设置默认参数
B ) 构造函数在说明类变量时自动执行
C ) 构造函数可以对静态数据成员进行初始化
D ) 构造函数可以重载
35、 对于类 A,语句void (A::*P ) (void ) ;表明( A )
A ) P是一个指向类成员函数的指针 B ) P是类A的一个成员
C ) P是类A的一个对象 D ) P是一个指向类对象的指针
36、运算符delete删除一个动态对象时( C )
A ) 首先为该动态对象调用构造函数,再释放其占用的内存
B ) 首先释放该动态对象占用的内存,再为其调用构造函数
C ) 首先为该动态对象调用析构函数,再释放其占用的内存
D ) 首先释放动态对象占用的内存,再为其调用析构函数
37、在类的定义形式中，数据成员、成员函数和（ A ）组成了类定义体
A） 成员的访问控制信息 B） 公有消息 C） 私有消息 D）保护消息
38、对于任意一个类，析构函数的个数最多为（ B ）
A） 0 B） 1 C） 2 D）3
39、（ C ）的功能是对对象进行初始化
A） 析构函数 B） 数据成员 C） 构造函数 D）静态数据成员
40、友元关系不能（ A ）
A）继承 B）是类与类之间是关系
C）是一个类的成员函数与另一个类的关系 D）提高程序的运行效率
41、（ A ）只能访问静态成员变量，静态成员函数和类以外的函数和数据不能访问类中的非静态成员变量
A） 静态函数 B） 虚函数 C）构造函数 D）析构函数
42、下面说法正确的是（ B ）
A） 内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方
B） 内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方
C） 类的内联函数必须在类体内定义
D）类的内联函数必须在类体外关键字inline定义
43、下列关于成员访问权限的描述中，不正确的是（ B ）
A） 公有数据成员和公有成员函数都可以被类对象直接处理
B） 类的私有数据成员只能被公有成员函数以及该类的任何友元类或友元函数访问
C） 保护成员在派生类中可以被访问，而私有成员不可以
D）只有类或派生类的成员函数和友元类或友元函数可以访问保护成员
44、局部变量可以隐藏全局变量，那么在有同名全局变量和局部变量的情形时，可以用（ A ）提供对全局变量的访问
A） 域运算符 B） 类运算符 C） 重载 D）引用
45、缺省析构函数的函数体是（ C ）
Ａ）不存在 Ｂ）随机产生的 Ｃ）空的 Ｄ）无法确定的、
46、在下列关键字中，用以说明类中公有成员的是（ A ）
A） public B） private C） protected D）friend
47、下面说法中正确的是（ B ）
A） 一个类只能定义一个构造函数，但可以定义多个析构函数
B） 一个类只能定义一个析构函数，但可以定义多个构造函数
C） 构造函数与析构函数同名，只要名字前加了一个求反符号（~）
D）构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以
48、关于delete 运算符的下列描述中，（ C ）是错误的
A） 它必须用语new返回的指针
B） 它也适用于空指针
C） 对一个指针可以使用多次该运算符
D）指针名前只用一对方括号符，不管所删除数组的维数
49、关于成员函数的特征的下述描述中，错误的是（ A ）
A） 成员函数一定是内联函数 B） 成员函数可以重载
C） 成员函数可以设置参数的默认值 D）成员函数可以是静态的
50、假定x为一个类，执行X a[3],*p[2];语句时会自动调用该类的构造函数（ B ）次
A） 2 B） 3 C） 4 D）5
51、由于数据隐藏的需要，静态数据成员通常被说明为（ A ）
A） 私有的 B） 公有的 C） 保护的 D）不可访问的
52、假定MyClass为一个类，则该类的拷贝构造函数的声明语句为（ C ）
A） MyClass(MyClass x ) B） MyClass&(MyClass x )
C） MyClass(MyClass &x ) D）MyClass(MyClass *x )
53、关于new运算符的下列描述中,( D ) 是错误的.
A ) 它可以用来动态创建对象和对象数组
B ) 使用它创建对象或对象数组,可以使用运算符DELETE删除
C ) 使用它创建对象时要调用构造函数
D ) 使用它调用对象数组时不允许指定初始值
54、对于常成员函数，下列描述正确的是（ C ）
Ａ）常成员函数只能修改常数据成员 B）常成员函数只能修改一般数据成员
C）常成员函数不能修改任何数据成员 D ) _成员函数只能通过常对象调用
55、友元的作用是（ A ）
Ａ）提高程序是运行效率 B）加强类的封装性
C）实现数据的隐藏性 D ) 增加成员函数的种类
56、一个类的友元函数或友元类能够通过成员操作符访问该类的（ D ）
A） 私有成员 B） 公有成员
C） 保护成员 D）公有成员、保护成员和私有成员
57、下面说法中正确的是（ D ）
A） 当声明的内容不同时，声明同一个名字的两个类是允许的
B） 不完全声明的类也可以实例化
C） 声明同一个名字的两个类时，要求声明的内容也相同
D）声明同一个名字的两个类是错误的
58、下面对静态数据成员的描述中，正确的是（ A ）
A） 静态数据成员是类的所有对象共享的数据
B） 类的每个对象都有自己的静态数据成员
C） 类的不同对象有不同的静态数据成员值
D）静态数据成员不能通过类的对象调用
59、下列关于对象数组的描述中，错误的是（ D ）
A） 对象数组的下标是从0开始的
B） 对象数组的数组名是一个常量指针
C） 对象数组的没个元素是同一个类的对象
D）对象数组只能赋初值，而不能在定义后赋值
60、对于下面定义的类A在函数f( ) 中将对象成员n的值修改为60的语句应该是（ C ）
class A
{
public:
A(int x ) {n=x;}
coid SetNum(int n1 ) {n=n1;}
private
int n;
}
int f( )
{
A*ptr=new A(6 ) ;
}
A） A(60 )
B） SetNum(60 )
C） Ptr->SetNum(60 )
D）Ptr->n=60
61、已知:print( ) 函数是一个类的常成员函数,它无返回值,下列表示中,( A ) 是正确的
A ) void print( ) const
B ) const void print( )
C ) void const print( )
D ) void print(const )
62、下面是类MyClass的定义，对定义中各语句描述正确的是（ D ）
class MyClass
{
private:
int X,y,Z;
public;
void MyClass(int a ) {X=a;} file://①
int f(int a,int b ) file://②
{
X=a;
Y=b;}
Int f(int a,int b,int c=0 ) file://③
{X=a;
Y=b;
Z=c;}
Static void g( ) {X=10;} file://④
A） 语句①是类MyClass的构造函数定义
B） 语句②和语句③实现类成员函数的重载
C） 语句④实现对类成员变量X的更新操作
D）语句①②③和④都不正确
63、友元访问类的对象的成员时使用（ D ）
A） 类的成员名 B） this指针指向成员名
C）“类名：：成员名”的形式 D） “对象名.成员名”的形式
64、下列程序输出的结果正确的是（ B ）
＃include<iostream.h>
coid fun( )
{static int n=10;
n++;
cout <<”n=”<<n<<endl;
}
int main( )
{
for (int I=1;I<3;I++ )
fun( ) ;
}
A）n=11 n=11 B ) n=11 n=12
C ) n=10 n=11 D ) n=10 n=10
65、 下面类模板的定义中，不正确的是（ C ）
A） template<class T>
class A{T x,y;};
B） template<class T>
class A{private:T x;};
C） template<class T>
class A{public:T x;};
D）template<class T>
class A{protected:t x;};
66、 静态成员遵循类的其他成员所遵循的访问限制，除了（ B ）
A） 静态成员函数 B） 静态数据成员初始化
C） 私有静态数据成员 D）公有静态成员函数
67、 空类的声明（ B ）是正确
A） class类名； B） class类名{}；
C） class类名{} D）class类名
68、 可以用“px->*p”来访问类A的对象a 的数据成员，则下面正确的是（ B ）
A） px是指向类数据成员的指针 B）p是指向类数据成员的指针
C） p是指向类的对象的指针 D）无法确定指针类型
69、 关于类中数据成员的生存期的说法正确的是（ D ）
A） 与对象的生存期无关 B） 比对象的生存期长
C） 比对象的生存期短 D）有对象的生存期决定
70、 类example 的析构函数为（ D ）
Ａ）example（）； Ｂ）example（）
Ｃ）~example（）； D）~example（）
71、 以知AA是一个类，则执行语句AA a；后（ A ）
Ａ）自动调用无参构造函数 B）自动调用有参构造函数
C ) 自动调用拷贝构造函数 D ) 产生一个对象a,但不调用任何函数
72、对于类模板tanytemp,执行语句tanytemp<int>iobject(23,32 ) ;后( C )
A ) 产生的模板类为 tanytemp
B ) 产生的模板类为 iobject
C ) 产生的模板类为 tanytemp<int>
D ) 类模板实例化对象
74、类的构造函数被自动调用执行的情况是在定义该类的( C )
A ) 成员函数时 B ) 数据成员时 C ) 对象时 D ) 友元函数时
75、说明友元函数使用关键字( A )
A ) friend B ) static C ) const D ) colatile
76、 有关类的作用域.，下面说法中不正确的是( B )
A ) 说明类时所使用的一对花括号形成所谓的类作用域
B ) 类作用域不包含类汇总成员函数的作用域
D ) 类作用域中说明的标识符只在类中可见
F ) 在可能出现两义性的情况下,必须使用作用域限定符”::”
77、 类的静态成员( C )
A ) 是指静态数据成员 C ) 是指静态函数成员
C ) 为该类的所有对象共享 D ) 遵循类的其他成员做遵循的所有访问权限
78、 允许访问类的所有对象的私有成员,公有成员和保护成员的是( A )
A ) 友元函数 B ) 成员函数 C ) 内置函数 D ) 重载函数
79、 形如X::X(X& ) 的构造函数称为( D )
A ) 拷贝函数 B ) 复制函数 C ) 初始化函数 D ) 拷贝初始化构造函数
80、已知example是已定义的类,则程序结束前,共存在( B ) 个对象.
＃include<example.h>
main( )
{ example x(5 ) ;
example arr[2]={1,2};
x=10;
x.print( ) ;
x=example(15 ) ;
x.print( ) ;
}
A ) 3 B ) 4 C ) 7 D ) 8
81、 所有在函数中定义的变量,连同形式参数,都属于( B )
A ) 全局变量 B ) 局部变量 C ) 静态变量 D ) 寄存器变量
82、在C++中,封装是借助于( B ) 达到的.
A ) 结构 B ) 类 C ) 数组 D ) 函数
83、 下面不属于类的存取权限的是( B )
A ) public B ) static C ) protected D ) private
84、 指向类X中类型为type的数据成员的指针的说明形式为( A )
A ) type X::*pointer B ) X::type*pointer C ) type *X::pointer D ) X::*type pointer
85、 已知:print( ) 函数是一个类的常成员函数,它无返回值,下列表示中,( A ) 是正确的
A ) void print( ) const B ) const void print( )
C ) viod const print( ) D ) void print(const )
下面正确的叙述是（ C ）
A. A::func2( ) 和B::func1( ) 都是虚函数
B. A::func2( ) 和B::func1( ) 都不是虚函数
C. B::func1( ) 是虚函数，A::func2( ) 不是虚函数
D. B::func1( ) 不是虚函数，A::func2( ) 是虚函数
86、对于多重继承，有（ D ）
A.一个派生类只能有一个基类 B.一个基类只能产生一个派生类
C.一个基类必须产生多个派生类 D.一个派生类可有多个基类
87、下列程序段中，错误的语句是（ C ）
class A{
public:virtual void f( ) =0; (1 )
void g( ) {f( ) ;} (2 )
A( ) {f( ) ;} (3 )
}
A.（1） B.（2） C.（3） D.（1）和（2）
88、下面程序段中，说法正确的是（ D ）
class location{
public :
int GetX( ) ;
};
class rectangle:private location {
public:
int GetW( ) ;
};
A.类rectangle的私有派生类是location
B.类rectangle中的public成员在类 location中是私有的
C.类location中的public成员在类 rectangle中是不可访问的
D. viod f( ) { Rectangle r; Int X=r .GetX( ) ; }
其中int X = r .GetX( ) ;是非法语句
89、在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是（ C
A.派生类的对象可以赋给基类对象
B.派生类的对象可以初始化基类的引用
C.派生类的对象可以直接访问基类的成员
D.派生类的对象的地址可以赋给指向基类的指针
90、可以用p.a的形式访问派生类对象p 的基类成员a其中a是（ D ）
A.私有继承的公有成员 B.公有继承的私有成员
C.公有继承的保护成员 D.公有继承的公有成员
91、建造新的派生类是（ C ）的实质
A.派生 B.抽象 C.继承 D.封装
92、动态联编所支持的多态性称为（ D ）
A.虚函数 B.继承 C.编译时的多态性 D.运行时的多态性
27、下列表示引用的方法中， A 是正确的
已知：int k=1000;
A ) int &x=k; B ) char &y; C ) int &z=1000; D ) float &t=&k;
28、下列程序的执行结果为 A
＃i nclude<iostream.h>
void mian( )
{
int n=10;
int* pn=&n;
int* &rn=pn;
(*pn ) ++;
cout<<"n="<<n<<endl;
(*rn ) ++;
cout<<”n=”<<n<<endl;
}
A ) n=11 n=12 B ) n=11 n=11
C ) n=10 n=11 D ) n=11 n=10
29、下列引用的定义中， B 是错误的
A ) int i; int &j=i; B ) int i; int &j; j=i;
C ) float i; float &j=i; C）char d; char &k=d;
30、 B 是给对象取了一个别名，他引入了对象的同义词
A ) 指针 B ) 引用 C ) 枚举 D ) 结构
31、下列表示引用的方法中， A 是正确的
已知：int m=10;
A ) int &x=m; B ) int &y=10; C ) int &z; D ) float &t=&m;
32、下面程序的运行结果是 A
＃i nclude<iostream.h>
void fun(int &a,int &b )
{ int p;
p=a; a=b; b=p;
}
void exchange(int &a,int &b,int &c )
{
if(a<b ) fun(a,b ) ;
if(a<c ) fun(a,c ) ;
if(b<c ) fun(b,c ) ;
}
int main( )
{
int a,b,c;
a=12;
b=639;
c=78;
exchange(a,b,c ) ;
cout<<"a="<<a<<",b="<<b<<",c="<<c<<endl;
}
A ) a=639,b=78,c=12 B ) a=12,b=639,c=78
C ) a=639,b=12,c=78 D ) a=78,b=12,c=639
33、下面的程序输出结果为 C
＃include<iostream.h>
int main( )
{
int *ir;
int i;
ir=&i;
i=17;
cout<<"int i="<<i<<endl;
cout<<"int ir="<<*ir<<endl;
}
A ) int i=17 int ir=0 B ) int i=0 int ir=17
C ) int i=17 int ir=17 D ) 程序语法错误，没有输出结果
34、对定义重载函数的下列要求中， D 是错误的
A ) 要求参数的个数不同 B ) 要求参数中至少有一个类型不同
C ) 要求参数个数相同时，参数类型不同 D ) 要求函数的返回值不同
35、下面函数调用语句中实参的个数是 A
xxx((v1,v2 ) ,(v3,v4,v5 ) ,v6 ) ;
A ) 3 B ) 4 C ) 5 D ) 6
36、系统在调用重载函数时往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据的是 D
A ) 参数个数 B ) 参数的类型 C ) 函数名称 D ) 函数的类型
37、若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是 D
A ) extern B ) register C ) auto D ) static
38、在C++中，关于下列设置参数默认值的描述中，正确的是 C
A ) 不允许设置设置参数的默认值
B ) 设置参数默认值只能在定义函数时设置
C ) 设置参数默认值时，应该事先设置右边的再设置左边的
D ) 设置参数默认值时，应该全部参数都设置
39、若有下面函数调用语句：
fun(a+b,(x,y ) ,fun(n+k,d,(a+b ) ) ) ;
在此函数调用语句中实参的个数是 A
A ) 3 B ) 4 C ) 5 D ) 6
40、下列对重载函数的描述中， A 是错误的
A ) 重载函数中不允许使用默认参数
B ) 重载函数中编译时根据参数表进行选择
C ) 不要使用重载函数来描述毫无相干的函数
D ) 构造函数重载将会给初始化带来多种方式
41、在函数声明时，下列 D 项是不必要的
A ) 函数的类型 B ) 函数参数类型 C ) 函数的名字 D ) 返回值表达式
42、在函数的返回值类型与返回值表达式的类型的描述中，错误的是 B
A ) 函数返回值的类型是在定义函数时确定，在函数调用时是不能改变的
B ) 函数返回值的类型就是返回值表达式的类型
C ) 函数返回值表达式类型与返回值类型不同时，函数表达式类型应转换成返回值类型
D ) 函数返回值类型确定了返回值表达式的类型
43、下面变量和函数说明：
＃i nclude<iostream.h>
char ch='*';
void sub(int x,int y,char ch,double *z )
{
switch(ch )
{
case '+':*z=x+y;break;
case '-':*z=x-y;break;
case '*':*z=x*y;break;
case '/':*z=x/y;break;
}
}
下面合法的函数调用语句是 B
A ) sub(10,20,ch,y ) ; B ) sub(1、2,3、2,'+',&z ) ;
C ) sub(sub(1,2,'+',&y ) ,sub(3,4,'+',&x ) ,'-',&y ) ; D ) sub(a,b,&x,ch ) ;
44、下列程序的输出结果是 B
＃include<iostream.h>
void sub1(char a,char b )
{ char c;
c=a; a=b; b=c;
}
void sub2(char *a,char b )
{
char c;
c=*a; *a=b; b=c;
}
void sub3(char *a,char *b )
{
char c;
c=*a; *a=*b; *b=c;
}
int main( )
{
char a,b;
a='A';
b='B';
sub1(a,b ) ;
putchar(a ) ;
putchar(b ) ;
a='A';
b='B';
sub2(&a,b ) ;
putchar(a ) ;
putchar(b ) ;
a='A';
b='B';
sub3(&a,&b ) ;
putchar(a ) ;
putchar(b ) ;
putchar('\n' ) ;
}
A ) ABABAB B ) ABBBBA C ) ABBABA D ) ABABBA
45、下面程序的正确执行结果为 D
＃include<iostream.h>
int f(int ) ;
int main( )
{
int a=2,i;
for(i=0;i<3;i++ )
cout<<f(a ) <<" ";
cout<<endl;
}
int f(int a )
{
int b=0;
static int c=3;
b++;
c++;
return (a+b+c ) ;
}
A ) 7 7 7 B ) 7 10 13 C ) 7 9 11 D ) 7 8 9
46、下面程序的正确执行结果为 C
＃i nclude<iostream.h>
void fun(char * *m )
{
m++;
cout<<*m<<endl;
}
int main( )
{
static char *a[]={"MORNING","AFTERNOON","EVENING"};
char * *n;
n=a;
fun(n ) ;
}
A ) 为空 B ) MORNING C ) AFTERNOON D ) EVENING
47、下面程序的输出结果 B
＃i nclude<iostream.h>
int fun(char *s )
{
char *p=s;
while(*p!='\0' )
p++;
return (p-s ) ;
}
int main( )
{
cout<<fun("ABCDEF" ) <<endl;
}
A ) 3 B ) 6 C ) 8 D ) 0
48、当一个函数无返回值时，函数的类型应定义为 A
A ) void B ) 任意 C ) int D ) 无
49、下面叙述中不正确的是 D
A ) 在函数中，通过return语句传回函数值
B ) 在函数中，可以有多条return语句
C ) 主函数名main( ) 后面的一对圆括号中也可以带有形参
D ) 调用函数必须在一条独立的语句中完成
50、下列 D 的调用方式是引用调用
A ) 形参是指针，实参是地址值 B ) 形参和实参都是变量
C ) 形参是数组，实参是变量 D ) 形参是引用，实参是变量
51、在C++中，函数原型不能标识 D
A ) 函数的返回类型 B ) 函数参数的个数 C ) 函数参数类型 D ) 函数的功能
52、下列标识符中， C 是文件级作用域的
A ) 函数形参 B ) 语句标号 C ) 外部静态类标识符 D ) 自动类标识符
53、在传值调用中，要求 C
A ) 形参和实参类型任意，个数相等 B ) 实参和形参类型都完全一致，个数相等
C ) 实参和形参对应的类型一致，个数相等 D ) 实参和形参对应的类型一致个数任意
54、有一个int型变量，在程序中频繁使用，最好定义它为 A
A ) register B ) auto C ) extern D ) static
55、考虑下面的函数原型：void testDefaulParam(int a,int b=7,char z='*' ) ;
下面函数调用中不合法的 C
A ) testDefaulParam(5 ) ; B ) testDefaulParam(5,8 ) ;
C ) testDefaulParam(5,'#' ) ; D ) testDefaulParam(0,0,'*' ) ;
56、采用函数重载的目的在于 D
A ) 实现共享 B ) 减少空间 C ) 提高速度 D ) 使用方便，提高可靠性
57、要求通过函数来实现一种不太复杂的功能，并且要加快执行速度，选
用 A
A ) 内联函数 B ) 重载函数 C ) 递归函数 D ) 嵌套函数
58、下面程序的输出结果是 D
＃i nclude<iostream.h>
void fun(int i ) ;
int main( )
{
int n=2;
fun(n ) ;
return 0;
}
void fun(int i )
{
static int x=1;
int y=1;
if(i>0 )
{
++x;
++y;
cout<<x<<' '<<y<<' ';
fun(i-1 ) ;
}
}
A ) 语法错误，不能输出正确结果 B ) 2 2 2 2 C ) 2 2 3 3 D ) 2 2 3 2
59、下面程序的输出结果为 B
＃i nclude<iostream.h>
void prt(int *x,int *y,int *z )
{
cout<<+ + *x<<","<<+ + *y<<","<<*(z++ ) <<endl;
}
int a=10;
int c=20;
int b=40;
int main( )
{
prt(&a,&b,&c ) ;
prt(&a,&b,&c ) ;
}
A ) 11,42,31 12,21,41 B）11,41,20 12,42,20
C ) 11,21,40 11,21,41 D ) 11,41,21 12,42,22
60、下面程序的正确运行结果为 C
＃i nclude<iostream.h>
fun(int a,int b )
{
static int m=1,i=2;
i+=m+1;
m=i+a+b;
return(m ) ;
}
int main( )
{
int k=5,m=2,p;
p=fun(k,m ) ;
cout<<p<<",";
p=fun(k,m ) ;
cout<<p<<endl;
}
A ) 11,22 B ) 12,23 C ) 11,23 D ) 10,23
61、下面程序的输出结果是 D
＃i nclude<iostream.h>
void fun(int *s,int *y )
{
static int t=3;
*y=s[t];
t--;
}
int main( )
{
int a[]={1,2,3,4};
int i,x=10;
for(i=0;i<4;i++ )
{
fun(a,&x ) ;
cout<<x<<",";
}
cout<<endl;
}
A ) 1,2,3,4 B ) 0,0,0,0 C ) 4,4,4,4 D ) 4,3,2,1
62、下面程序的输出结果是 A
＃i nclude<iostream.h>
int fun(char *s )
{
char *p=s;
while(*p!='\0' )
p++;
return (p-s ) ;
}
int main( )
{
cout<<fun("ABCDEFGHIJKLMNIPQRST" ) <<endl;
}
A ) 20 B ) 6 C ) 19 D ) 0
63、下面程序的输出结果是 C
＃i nclude<iostream.h>
int x=10;
void fun(int c ) ;
int main( )
{
fun(x ) ;
cout<<"x="<<x<<endl;
}
void fun(int x )
{
x=1;
}
A ) x=0 B ) x=1 C ) x=10 D ) 语法错误，不能输出正确结果
64、下面程序的执行结果是 B
#include<iostream.h>
int main( ) {
void swap( );
extern int a, b;
a = 3;
b = 10;
swap( );
cout << "a=" << a << ",b=" << endl;
}
int a, b;
void swap( ) {
int temp;
temp = a;
a = b;
b = temp;
}
A ) a=3,b=10 B ) a=10,b=3 C ) a=temp,b=temp D ) 语法错误，不能输出正确结果
65、下列程序的输出结果是 A
＃include<iostream.h>
void f( )
{
static int i=15;
i++;
cout<<"i="<<i<<endl;
}
int main( )
{
for(int k=0;k<2;k++ )
f( ) ;
}
A ) i=16 i=17 B ) i=16 i=15 C ) i=15 i=16 D ) i=15 i=17
66、在横线处填上适当的语句 C ，使下面程序执行结果是13，18，23
＃include<iostream.h>
int add(int x,int y=8 ) ;
int main( )
{
;
cout<<add(a ) <<",";
cout<<add(a,add(a ) ) <<",";
cout<<add(a,add(a,add(a ) ) ) <<endl;
}
int add(int a,int b )
{
int s=a+b;
return s;
}
A ) int a=3 B ) int b=3 C ) int a=5 D ) int b=5
67、在横线处填上适当的语句 A ，使下面的程序的执行结果是19 24 30 37 45
＃include<iostream.h>
int fun(int a )
{
static int x=10;
int y=1;
x+=a;
a++;
y++;
return(x+y+a ) ;
}
int main( )
{
int i=3;
while(i<8 )
;
cout<<endl;
}
A ) cout<<fun(i++ ) <<" " B ) cout<<fun(i ) <<" "
C ) cout<<fun(i++ ) <<" ," D ) cout<<fun(i ) <<" ,"
68、在C++语言中，局部变量的隐含存储类型是 D
A ) auto B ) static C ) extern D ) 无存储类型
69、下面程序的输出结果为 D
＃include<iostream.h>
int fun(char *s ) ;
int main( )
{
cout<<fun("hello" ) ;
return 0;
}
int fun(char *s )
{
char *t=s;
while(*t!='\0' )
t++;
return(t-s ) ;
}
A ) 语法错，不能输出正确结果 B ) 0 C ) 6 D ) 5
