C++二级试题选择题练习(带注解,答案)

1.以下运算符函数中肯定不属于类FunNumber的成员函数的是__D____。

本题考查的是类的成员函数。

选项A是重载了负号或减法运算符，由于减法运算符它具有两个操作数，而题面原型中只有一个，如果重载的是减号运算符，则必为成员函数。

选项B中由于没参数，无论是负号或减法运算符至少具有一个参数，所以它必为成员函数，同时也必定是重载了负号运算符。

选项C是必定以成函数的方式重载，因为C++规定不能对内置类的运算符进行重载，所以它不可能是友元函数（因为操作数为内置的int型），所以必为成员函数重载，且必定是重载了减法运算符。

选项D有两个参数，无论是负号或减法运算符，其操作数不超2个，所以必定为友元函数重载，且重载了减法运算符。

故本题答案为D。

2.运算符重载是对已有的运算符赋予多重含义，因此__C____。

本题主要考查了运算符重载。

C++在重载运算符时，必须符合下面的条件：
1、不能重载内置C++数据类型（如int，double等类型）的运算符的含义；
2、不能定义C++中没有的运算符；
3、不能改变重载运算符的优先级与操作数的个数；
4、有些运算符不能被重载，如域运算符（::），条件运算符（?:）等，具体哪些运算符不能被重载与编译器有关。

3.有如下程序：
#include <iostream>
using namespace std;
class Complex
{
double re,im;
public:
Complex (double r,double i):re(r),im(i) { }
double real() const {return re;}
double image() const { return im;}
Complex& operator+=(Complex a)
{
re+=a.re ;
im+=a.im ;
return *this ;
}
};
ostream& operator<<(ostream& s,const Complex& z)
{
return s<<'('<<z.real()<<','<<z.image()<<')';
}
int main()
{
Complex x(1,-2),y(2,3);
cout<<(x+=y) <<endl;
return 0;
}
执行这个程序的输出结果是_(3,1)_____。

4.在重载一个运算符为成员函数时，其参数中没有任何参数，这说明该运算符是__A____。

A.前缀一元运算符
B. 二元运算符
C. 后缀一元运算符
D. 无操作数运算符
5. 下面程序中对一维坐标点类Point进行运算符重载
#include <iostream>
using namespace std;
class Point{
public:
Point(int val) {x=val;}
Point& operator ++(){x++;return *this;}
Point operator ++(int) {Point old=*this;++(*this);return old;}
int GetX() const {return x;}
private:
int x;
};
int main()
{
Point a(10);
cout<<(++a).GetX();
cout<<a++.GetX();
return 0;
}
编译和运行情况是_运行时输出 1111_____。

本题考查的是运算符重载。

对于++，--运算符有前置与后置两种方式，在以成元函数方式重载该运算符时，对于前置运算符可以以通常的一元运算的方式进行重载，对于后置运算符，则需在参数列表中加一个辅助类型的参数，以便于前置运算符区别。

本题的输出结果为1111。

6.关于虚函数，下列表述正确的是__B____。

本题考查的是虚函数的一些基本概念。

在成员函数前加上virtual修饰，即把该函数声明为虚函数。

虚函数可以是另一个类的友元函数，但不得是静态成员函数。

故本题选B。

7.下列关于虚函数的说明中，正确的是_A_____。

8.有如下程序：
#include <iostream>
using namespace std;
class Base{
public:
void output() { cout<<1;}
virtual void Print(){cout<<'B';}
};
class Derived : public Base{
public:
void output() {cout<<2;}
void Print() { cout<<'D';}
};
int main(){
Base *ptr=new Derived;
ptr->output();
ptr->Print();
delete ptr;
return 0;
}
程序的输出结果是__1D____。

virtual void Print(){cout<<'B';}表示这方法是虚函数，虚函数的意思是如果子类有继承这虚函数，则子类的对象在执行此方法时调用子类的此方法。

否则会调用基类的此方法。

在此程序中Derived是子类，Base是基类，Base *ptr=new Derived;创建一个子类的对象给基类的指针对象。

ptr->output();因为指针ptr是基类的对象。

所以在执行output()方法时会调用基类的output()方法，也就是Base类的output()方法。

不会调用Derived类的output()方法，因为output()不是虚函数。

输出1。

ptr->Print(); 因为Print();在基类Base中申明是虚函数，所以在子类中如果有继承此方法就会调用子类的这方法。

所以这个调用的是Derived类的Print();方法。

输出D。

故本题答案为B。

9.在C++中用来实现运行时多态性的是__虚函数____。

10. 下列关于派生类的描述中错误的是__D____。

本题考查了派生类的基本概念。

继承方式有3种：公有继承、私有继承和保护继承。

如果不显式地给出继承方式，缺省的继承方式是私有继承。

派生类从基类继承来所有的成员，但是基类的私有成员派生类是不可直接访问的。

所以本题选D。

11.下列说法中错误的是__B____。

题考查的是继承的类型。

类的继承方式有公有继承、保护继承和私有继承三种方式。

对于公有继承基类中的成员访问属性不变，对于保护和私有继承基类中的成员转换为相应的访问类型。

但是如果基类成员的访问属性为private的，则不能被继承。

故本题选B。

12.如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员。

有如下程序，没有使用多态机制。

#include<iostream>
using namespace std;
class Base{
int a,b;
public:
Base(int x,int y) { a=x; b=y; }
void show(){ cout<<a<< ','<<b<<endl; }
};
class Derived:public Base {
int c,d;
public:
Derived(int x,int y,int z,int m):Base(x,y){c=z; d=m; }
void show() {cout<<c<< ','<<d<<endl;}
};
int main()
{
Base B1(50,50),*pb;
Derived D1(10,20,30,40);
pb=&D1;
pb->show();
return 0;
}
运行时输出的结果是_10,20_____。

本题考查的是继承与多态。

由于函数show是非虚拟的，故其调用依据其指针类型决定，而pb是一个指向Base的指针，故在调用show时，将调用Base::show，输出成员变量a,b，而pb是指向变量D1的，
D1在实例化时，将基类中a,b初始化为10、20，故本题的输出为10,20。

13. void dispb(){dispa();cout<<x<<endl;}
private:
int x;
};
int main()
{
B b(2);
b.dispb();
return 0;
}
运行时输出的结果是_12,2_____。

本题考查的是类的继承与实例化。

"B b(2);"以整数2实例化变量b，在执行B的构造函数时，以i+10即12去调用类B的父类的构造函数，从而将A::x初始化为12，然后将B::x赋值为2。

在执行b.dispb()时，先调用了父类中dispa，输出A::x，即12，再输出B::x，即2，从而运行结果为"12,2"
14. 下列说法中错误的是__B____。

本题考查了派生类的定义和访问权限。

当以public方式继承时，基类成员中private成员不能被访问，public成员在子类中仍是public成员，protected成员仍是protected成员。

当以protected方式继承时，基类成员中private成员不能被访问，public成员与protected成员在子类中均是protected成员。

当以private方式继承时，基类成员中private成员不能被访问，public成员与protected成员在子类中均是private成员。

15.有以下程序：
#include <iostream>
using namespace std;
class Base{
public:
Base(int x=0) {cout<<x;}
};
class Derived : public Base{
public:
Derived(int x=0) {cout<<x;}
private:
Base val;
};
int main(){
Derived d(1);
return 0;
}
程序的输出结果是_001____。

本题考查的是类的相关知识。

"Base val;"因为类Derived 有个Base类的对象val为私有变量。

所以在给这类创建对象时会创建Base val;对象。

在Derived d(1);创建对象d时先创建Base的对象val，执行Base类的Base(int x=0) {cout<<x;}方法，输出0；
接着创建类Derived对象d 执行类Derived的带一个参数的构造方法Derived(int
x=0) {cout<<x;}，在执行前因为类Derived是公共继承类Base所以先执行基类的构造方法Base(int x=0) {cout<<x;}输出0（这个方法是给参数赋默认值的；int x=0意思是如果没有传参数过来就以0表示这个参数的值）；
执行完基类的构造方法后执行自已的构造方法。

因为传的参数为1所以输出1。

16.在下面的类定义中，横线处应填入的内容是__int Fred::____。

class Fred
{
public:
void print(){cout<<data<<endl;}
void setData(double d){data=d;}
static int count;
private:
double data;
};
count=0; //静态数据成员定义
17.有如下程序：
#include <iostream>
using namespace std;
class Test
{
public:
Test(){n+=2;}
~Test(){n-=3;}
static int getNum(){return n;}
private:
static int n;
};
int Test::n=1;
int main()
{
Test*p=new Test;
delete p;
cout<<"n="<<Test::getNum()<<endl;
return 0;
}
执行后的输出结果是__n=0____。

本题主要考查了C++中类的静态成员。

由于n是类Test的静态成员，该成员被类的所有实例共享。

当程序执行new Test 操作时，类的构造函数将被执行，执行后Test::i的值为3，调用delete p后将执行Test的析构函数，执行后，i的值将减3，此时Test::i的值为0。

Test::getNum()为Test类的一个静态成员函数，其作用是返回私有静态成员变量i的值，故本题输出为"n=0"，
18. 假定MyClass为一个类，则该类的拷贝构造函数的声明语句为___MyClass(MyClass &x)___。

19.类的默认的无参构造函数___A___
20.对于下面的类定义，如果要为其添加一个析构函数，对于析构函数定义正确的是
_~MyFirst(){}_____。

class MyFirst
{
private:
int a;
public:
MyFirst(int giva_a=0){a=give_a;}
}
21.下面类定义中错误的语句是__A____。

class Sample
{
public:
Sample(int val);
~Sample(int val);
private:
int a;
Sample();
}
A. ~Sample(int val);
B. Sample(int val);
C. int a;
D. Sample();
22.对于结构中定义的成员，其隐含访问权限为__public____。

结构体默认的访问权限是public，而类默认的访问权限是private。

23. 有以下类定义
class Point{
public:
Point(int x=0,int y=0){_x=x;_y=y;}
void Move(int xOff,int yOff)
{_x+=xOff;_y+=yOff;}
void Print() const
{cout<<'('<<_x<<','<<_y<<')'<<endl;}
private:
int _x,_y;
};
下列语句中会发生编译错误的是_C_____。

24.当使用fstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式
为__没有____。

在C++中用fstream流类定义一个流对象并打开一个磁盘文件时，没有隐含的打开方式。

25. 已知outfile是一个输出流对象，要想将outfile的文件指针定位到当前位置前321
字节处，正确的函数调用语句是__A____。

本题主要考查了C++文件流的操作。

在C++的输出文件流中可以用seekp在文件中定位，该函数的原型为ostream& seekp( streamoff off, ios::seek_dir dir );，其中off为偏移量，dir为偏移方向。

当dir为ios_base::cur时，表示以当前位置为基础移动off字节。

如果off<0则表示向前移动，否则是向后移动。

当dir为ios_base::beg，表示距文件开始位置off字节。

当dir为ios_base::end时，表示距文件结尾off字节。

26. 下列有关模板的叙述中，正确的是__A____。

27.关于关键字class和typename，下列表述中正确的是__D____。

28.关于类模板下列说法不正确的是__A____。

29.下面的函数模板定义中错误的是____A__。

A. template <class Q>
Q F(Q x){return Q+x;}
B. template <class Q>
Q F(Q x){return x+x;}
C. template <class T>
bool F<T x>{return x>1;}
D. template <class T>
T F(T x){return x*x;}
30.下列是模板声明的开始部分，其中正确的是___D___。

A. template<T>
B. template<class T1,T2>
C. template<class T1;class T2>
D. template<class T1,class T2>
31.对于下面定义的类MyClass,在函数f（）中将对象成员n的值修改为50的语句应该是__ptr->SetNum(50)____。

class MyClass
{
public:
MyClass(int x){n=x;}
void SetNum(int n1){n=n1;}
private:
int n;
}
int f()
{
MyClass *ptr=new MyClass(45);
_________;
}
32. 在C++面向对象程序设计框架中，__类____是程序的基本组成单元。

33. 若将一个二元运算符重载为类的成员函数，其形参个数应该是__1____个。

34.C++中的多态性分为编译时的多态性和运行时的多态性，其中运行时的多态性时通过
_虚函数_____实现的。

35. C++语言中的多态性分为编译时的多态性和__运行____时的多态性。

36. 在类的对象被创建的时候，_构造_____函数会被自动调用。

37. 有如下程序：
#include <iostream>
using namespace std;
class A {
public:
A(){cout<<"A";}
~A(){cout<<"A";}
};
class B {
A a;
public:
B(){ cout<< "B";}
~B(){cout<<"B";}
};
int main(){
B b;
return 0;
}
程序的输出结果是__ABBA____。

解析：main(){B b;
创建类B一个对象b，这时转到类B里去执行类B的构造方法B()，因为在类B里有个全局的类A的对象a，所以在执行构造方法B()之前会先创建类A的对象a，就去执行类A的构造方法A()，输出字符A，再返回到类B执行它的构造方法B()输出字符B，现在所有的构造方法执行完了，就执行析构方法了，因为析构方法与构造方法的执行顺序相反，所以先执行~B()方法输出字符B，再执行~A()输出字符A。

所以输出结果ABBA。

38. 设px是指向一个类动态对象的指针变量，则执行"delete px；"语句时，将自动调
用该类的__析构或析构函数____函数。

39. 已知int DBL(int n){return n+n;}和long DBL(Long n){return n+n;}
是一个函数模板的两个实例，则该函数模板的定义是__templateT DBL(T n){return n=+n}____。

40. 在声明派生类时，如果不显式地给出继承方式，缺省的类继承方式是私有继承private。

已知有如下类定义：
classe Base{
protected:
void fun(){}
};
class Derived:Base{};
则Base类中的成员函数fun()，在Derived类中的访问权限是__private____。

（注意：要求填写private、protected或public中的一项）。

本题考查的是派生类。

派生类的继承方式如果不显式的给出，缺省的继承方式是私有继承private。

派生类从基类私有继承时，基类的公有成员和保护成员在派生类中都改变为私有成员。

41. 如下程序声明了一个二维图形类TwoDShape，从其派生出矩形类Rec。

#include<iostream>
#include<string>
using namespace std;
class TwoDShape{ //二维图形类.
char name[20];
public:
TwoDShape(char *n="unknown"){
strcpy(name,n);
}
char *getName(){return name;}
=0;
};
class Rec:public TwoDShape{
double width,height;
public:
Rec(double w=0.0,double h=0.0):TwoDShape("rectangle")
{width=w;height=h;}
double getWidth(){return width;}
double getHeight(){return height;}
double area(){return width*height;}
};
int main(){
TwoDShape *shape;
shape=new Rec(2.1,3.0);
cout<<"object is "<<shape->getName()<<"\n",
cout<<"Area is "<<shape->area()<<"\n";
return 0;
}
请将程序补充完整，使程序在运行时输出：
object is triangle
Area is 6.3
答案：virtual double area()
42. 关于类的概念下列说法正确的是__B____。

43. 下面是重载为非成员函数的运算符函数原型，其中错误的是___C___。

44. 下列是重载乘法运算符的函数原型声明，其中错误的是___D___。

45. 下列关于运算符重载的叙述中，正确的是__A____。

A. 有的运算符只能作为成员函数重载
B. 通过运算符重载，可以定义新的运算符
C. 若重载运算符+，则相应的运算符函数名是+
D. 重载一个二元运算符时必须声明两个形参
46. 在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运
算符。

下列叙述中正确的是___C___。

47. 有如下程序
#include<iostream>
using namespace std;
class A{
public:
virtual void func1(){cout<<"Al";}
void func2(){cout<<"A2";}
};
class B:public A{
public:
void func1(){cout<<"B1";}
void func2(){cout<<"B2";}
};
int main(){
A*p=new B;
p->func1();
p->func2();
return 0;
}
运行此程序，屏幕上将显示输出__B1A2____。

本题考查的是派生类。

派生类B由基类A公有继承而来。

调用p->func1();后，执行派生类B的函数void func1()；调用p->func2();后，执行基类的函数void func2()，因为虚拟函数是根据对象的实际类型调用，非虚拟函数是根据指针类型调用。

故通过指针p调用func2时将直接调用基类中的void func2()。

48. 虚函数的_函数体内容_____可以不同。

49. 有如下程序：
#include <iostream>
using namespace std;
class Base
{
public:
Base(){cout<<"BB";f();}
void f(){cout<<"Bf";}
};
class Derived:public Base
{
public:
Derived(){cout<<"DD";}
void f(){cout<<"Df";}
};
int main(){Derived d;return 0;}
执行上面的程序将输出__BBBfDD____。

50. 关于抽象类，下列表述正确的是__C____。

51. 有如下程序：
#include <iostream>
using namespace std;
class Base
{
public:
void fun(){cout<<"Base::fun"<<end1endl;} };
class Derived:public Base
{
public:
void fun()
{
______
cout<<"Derived::fun"<<end1endl;
}
};
int main()
{
Derived d;
d.fun();
return 0;
}
已知其执行后的输出结果为：
Base::fun
Derived::fun
则程序中下划线处应填入的语句是___ Base::fun()___。

52. 有如下类声明：
class Base{
protected:
int amount;
public:
Base(int n=0):amount(n){}
int getAmount()const{return amount;}
};
class Derived:public Base{
protected:
int value;
public:
Derived(int m,int n):value(m),Base(n){}
int getData()const{return value+amount;}
};
已知x是一个Derived对象，则下列表达式中正确的是_A_____。

53. 在公有派生的情况下，派生类中定义的成员函数只能访问原基类的___公有成员和
保护成员___。

54. 有如下程序：
#include<iostream>
using namespace std;
class Point{
public:
static int number;
public:
Point(){number++;}
~Point(){number--;}
};
int Point::number=0;
void main(){
Point *ptr;
Point A,B;
{
Point* ptr_point=new Point[3];
ptr=ptr_point;
}
Point C;
cout<<Point::number<<endl;
delete[] ptr;
}
运行时输出的结果是__6____。

在程序运行时，首先将静态变量初始化为0，当实例化A、B时，将执行两次构造函数，number的值将变为2，语句"ptr_point=new Point[3];"定义了一个长度为3的Point型数组，从而又执行三次构造函数，number值为5，定义变量C时，再次执行Point的构造函数，最终number的值为6。

55. 下面是关于类MyClass的定义，对定义中的各语句描述正确的是______。

class MyClass
{
public:
void MyClass(int a){x=a} //1
int f(int a,int b) //2
{
x=a;y=b;
}
int f(int a,int b,int c=0) //3
{
x=a;y=b;z=c;
}
static void g(){x=10;} //4
private:
int x,y,z;
};
语句1、2、3、4都不正确
56. __C____不是构造函数的特征。

57. 对于下面的类定义，如果要为其添加一个析构函数，对于析构函数定义正确的是__ ~MyFirst(){}____。

class MyFirst
{
private:
int a;
public:
MyFirst(int giva_a=0){a=give_a;}
}。