C++练习题(附答案).doc

5.9
（11）下列关于 C++函数的叙述中，正确的是
A）每个函数至少要具有一个参数 B）每个函数都必须返回一个值
C）函数在被调用之前必须先声明 D）函数不能自己调用自己
（12）下列关于类和对象的叙述中，错误的是
A）一个类只能有一个对象
B）对象是类的具体实例
C）类是对某一类对象的抽象
D）类和对象的关系是一种数据类型与变量的关系
（13）在 C++中，用于实现运行时多态性的是
A）内联函数 B）重载函数
C）模板函数 D）虚函数
（14）下列关于运算符重载的叙述中，正确的是
A）通过运算符重载，可以定义新的运算符
B）有的运算符只能作为成员函数重载
C）若重载运算符+，则相应的运算符函数名是+
D）重载一个二元运算符时，必须声明两个形参
（15）下列关于模板的叙述中，错误的是
A）模板声明中的第一个符号总是关键字 template
B）在模板声明中用<和>括起来的部分是模板的形参表
C）类模板不能有数据成员
D）在一定条件下函数模板的实参可以省略
（16）对于语句 cout<中，正确的 C++标识符是
A）foo-1 B）2b
C）new D）_256
（18）已知枚举类型定义语句为：
enum Token{NAME,NUMBER,PLUS=5,MINUS,PRINT=10};
则下列叙述中错误的是
A）枚举常量 NAME 的值为 1 B）枚举常量 NUMBER 的值为 1
C）枚举常量 MINUS 的值为 6 D）枚举常量 PRINT 的值为 10
（19）执行语句序列
int i=0;while(i<25)i+=3;cout<5 个元素的一维数组 vect，并使其各元素的初值依次是 30，50，-88，0 和 0，则下列定义语句
中错误的是
A）int vect[]={30,50,-88}; B）int vect[]={30,50,-88,0,0};
C）int vect[5]={30,50,-88}; D）int vect[5]={30,50,-88,0,0};
（21）有如下程序：
#include
void fun(int& x,int y){int t=x;x=y;y=t;}
int main()
{
int a[2]={23,42};
fun(a[1],a[0]);
std::cout<n;}
int get()const{return k;}
};
class MyDERIVED:protected MyBASE
{
protected:
int j;
public:
void set(int m,int n){MyBASE::set(m);j=n;}
int get()const{return MyBASE::get()+j;}
};
则类 MyDERIVED 中保护的数据成员和成员函数的个数是
A）4 B）3
C）2 D）1
（24）已知在一个类体中包含如下函数原型：VOLUME operator-(VOLUME)const;，下列关于这个函数的叙述中，错误
的是
A）这是运算符-的重载运算符函数
B）这个函数所重载的运算符是一个一元运算符
C）这是一个成员函数
D）这个函数不改变类的任何数据成员的值
（25）有如下函数模板定义：
template
T func(T x,T y){ return x*x+y*y;}
在下列对 func 的调用中，错误的是
A）func(3,5); B）func(3.0,5.5);
C）func(3,5.5); D）func(3,5.5);
（27）在下列函数原型中，可以作为类 AA 构造函数的是
A）void AA(int);
B）int AA();
C）AA(int)const;
D）AA(int);
（28）下列关于 this 指针的叙述中，正确的是
A）任何与类相关的函数都有 this 指针
B）类的成员函数都有 this 指针
C）类的友元函数都有 this 指针
D）类的非静态成员函数才有 this 指针
（29）有如下程序：
#include
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="<
using namespace std;
class A {
public:
A(){cout<<"A";}
};
classB{public:B(){cout<<"B";}}
classC:public A{
B b;
public:
C(){cout<<"C";}
};
int main(){ C obj; return 0;}
执行后的输出结果是
A）CBA B）BAC
C）ACB D）ABC
（31）有如下类声明：
class XA{
int x;
public:
XA(int n){x=n;}
};
class XB:public XA{
int y;
public:
XB(int a,int b);
};
在构造函数 XB 的下列定义中，正确的是
A） XB::XB(int a,int b):x(a),y(b){} B）XB::XB(int a,int b):XA(a),y(b){}
C）XB::XB(int a,int b):x(a),XB(b){} D）XB::XB(int a,int b):XA(a),XB(b){}
（32）有如下程序：
#include
using namespace std;
class BASE{
public:
~BASE(){cout<<"BASE";}
};
class DERIVED:public BASE{
public:
~DERIVED(){cout<<"DERIVED";}
};
int main(){DERIVED x;return 0;}
执行后的输出结果是
A）BASE B）DERIVED
C）BASEDERIVED D）DERIVEDBASE
（33）在表达式 x+y*z 中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的
是
A）operator+有两个参数，operator*有两个参数
B）operator+有两个参数，operator*有一个参数
C）operator+有一个参数，operator*有两个参数
D）operator+有一个参数，operator*有一个参数
（34）下面关于 C++流的叙述中，正确的是
A）cin 是一个输入流对象
B）可以用 ifstream 定义一个输出流对象
C）执行语句序列 char *y="PQMN"; cout<80); 时，若键入
Happy new year
则 x 中的字符串是"Happy"
（35）有如下程序：
#include
using namespace std;
class AA{
int n;
public:
AA(int k):n(k){}
int get(){return n;}
int get()const{return n+1;}
};
int main()
{
AA a(5);
const AA b(6);
cout<}
（7）执行语句序列
int x=l0,&r=x;
cout<
using namespace std;
class Point
{
public:
Point(int xx=0,int yy=0) {X=xx;Y=yy;countP++;}
~Point(){countP--;}
int GetX(){return X;}
int GetY(){return Y;}
static void GetC(){cout<<"Object id＝"<vate 成员。
（10）派生类中的成员不能直接访问基类中的___________成员。
（11）下列程序的输出结果为 2，请将程序补充完整。
#include
using namespace std;
class Base
{
public:
___________void fun(){cout<<1;}
};
class Derived:public Base
{
public:
void fun(){cout<<2;}
};
int main()
{
Base*p=new Derived
p->fun();
delete p;
return 0;
}
（12）请将下列类定义补充完整。
class Base{public: void fun(){cout<<"Base::fun"< （14）B） （15）C）
（16）D） （17）D） （18）A） （19）C） （20）A）
（21）B） （22）C） （23）B） （24）B） （25）C）
（27）D） （28）D） （29）A） （30）D）
（31）B） （32）D） （33）C） （34）A） （35）B）
二、填空题
（6）j++ >=
（8）int Point::countP=0；
（9）友元
（10）私有或 private
（11）virtual
（12）Base::fun( );
6.4
（11）下列关于 C函数的说明中，正确的是
A）内联函数就是定义在另一个函数体内部的函数
B）函数体的最后一条语句必须是 return 语句
C）标准 C++要求在调用一个函数之前，必须先声明其原型
D）编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式
（13）下列关于虚函数的说明中，正确的是
A）从虚基类继承的函数都是虚函数
B）虚函数不得是静态成员函数
C）只能通过指针或引用调用虚函数
D）抽象类中的成员函数都是虚函数
（14）运算符重载是对已有的运算符赋予多重含义，因此
A）可以对基本类型（如 int 类型）的数据，重新定义“+”运算符的含义
B）可以改变一个已有运算符的优先级和操作数个数
C）只能重载 C++中已经有的运算符，不能定义新运算符
D）C++中已经有的所有运算符都可以重载
（15）模板对类型的参数化提供了很好的支持，因此
A）类模板的主要作用是生成抽象类
B）类模板实例化时，编译器将根据给出的模板实参生成一个类
C）在类模板中的数据成员都具有同样类型
D）类模板中的成员函数都没有返回值
（18）下列语句中，错误的是
A）const int buffer=256; B）const int temp;
C）const double *point; D）const double *rt=new double(5.5);
（20）有如下程序：
#include
using namespace std;
int main()
{
int *p;
*p = 9;
cout << "The value at p: " << *p;
return 0;
}
编译运行程序将出现的情况是
A） 编译时出现语法错误，不能生成可执行文件
B） 运行时一定输出：The value at p:9
C）运行时一定输出：The value at p:*9
D）运行时有可能出错
21）有如下程序：
#include
using namespace std;
int main()
{
void function(double val);
double val;
function(val);
cout<
class AA
{
int a;
public:
int getRef()const{ return &a; } //①
int getValue()const{ return a; } //②
void set(int n)const{ a=n; } //③
friend void show(AA aa)const{ cout<
（23）有如下程序：
#include
using namespace std;
class Base
{
public:
void fun() { cout<<"Base::fun"< Derived d;
d.fun();
return 0;
}
已知其执行后的输出结果为：
Base::fun
Derived::fun

则程序中下划线处应填入的语句是
A）Base.fun(); B）Base::fun();
C）Base->fun(); D）fun();
（24）下面是重载为非成员函数的运算符函数原型，其中错误的是
A）Fraction operator + (Fraction, Fraction); B）Fraction operator - (Fraction);
C）Fraction& operator = (Fraction&, Fraction); D）Fraction& operator += (Fraction&, Fraction);
（25）有如下函数模板：
template
T cast(U u) { return u; }
其功能是将 U 类型数据转换为 T 类型数据。已知 i 为 int 型变量，下列对模板函数 cast 的调用中正确的是
A）cast(i); B）cast<>(i);
C）cast(i); D）cast(i);
（26）若磁盘上已存在某个文本文件，其全路径文件名为 d:\ncre\test.txt，下列语句中不能打开该文件的是
A）ifstream file("d:\ncre\test.txt"); B）ifstream file("d:\\ncre\\test.txt");
C）ifstream file; file.open("d:\\ncre\\test.txt"); D）ifstream* pFile = new ifstream("d:\\ncre\\test.txt");
（27）有如下类定义：
class Foo
{
public:
Foo(int v) : value(v) { } // ①
~Foo() { } // ②
private:
Foo() { } // ③
int value = 0; // ④
};

其中存在语法错误的行是
A）① B）②
C）③ D）④
（28）有如下类定义：
class Point
{
int x_, y_;
public:
Point(): x_(0), y_(0) { }
Point(int x, int y =0): x_(x), y_(y) { }
};
若执行语句
Point a(2), b[3], *c[4];
则 Point 类的构造函数被调用的次数是
A）2 次 B）3 次
C）4 次 D）5 次
（29）有如下类定义：
class Test
{
public:
Test() { a = 0; c = 0; } // ①
int f(int a) const { this->a = a; } // ②
static int g () { return a; } // ③
void h(int b) { Test::b = b; }; // ④
private:
int a;
static int b;
const int c;
};
int Test::b = 0;

在标注号码的行中，能被正确编译的是
A）① B）②
C）③ D）④
（30）有如下程序：
#include
using namespace std;
class A
{
public:
A() { cout << "A"; }
~A() { cout << "~A"; }
};
class B : public A
{
A* p;
public:
B() { cout << "B"; p = new A(); }
~B() { cout << "~B"; delete p; }
};
int main()
{
B obj;
return 0;
}
执行这个程序的输出结果是
A）BAA~A~B~A B）ABA~B~A~A
C）BAA~B~A~A D）ABA ~A~B~A
（32）有如下程序：
#include ostream>
using namespace std;
class Base
{
public:
void fun1() { cout << "Base\n"; }
virtual void fun2() { cout << "Base\n"; }
};
class Derived : public Base
{
public:
void fun1() { cout << "Derived\n"; }
void fun2() { cout << "Derived\n"; }
};
void f(Base& b) { b.fun1(); b.fun2(); }
int main()
{
Derived obj;
f(obj);
return 0;
}

执行这个程序的输出结果是
A） B）
Base Base
Base Derived
C） D）
Derived Derived
Base Derived
（33）有如下程序：
#include
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<<'('< int n;
public:
SAMPLE(int i=0):n(i){}
void setValue(int n0);
};

下列关于 getValue 成员函数的实现中，正确的是
A） SAMPLE::setValue(int n0){ n=n0;}
B）void SAMPLE::setValue(int n0){ n=n0;}
C）void setValue(int n0){ n=n0;}
D）(int n0){ n=n0;}
（6）有一种只在循环语句或 switch 语句中使用的流程控制语句，表示该语句的关键字是___
（7）程序中有如下语句
for(int i=0; i<5; i++) cout<<*(p+i)<<",";
能够依次输出 int 型一维数组 DATA 的前 5 个元素。由此可知，变量 p 的定义及初始化语句是___________。
（8）若下面程序运行时输出结果为
1,A,10.1
2,B,3.5
请将程序补充完整。
#include
using namespace std;
int main()
{
void test(int, char, double ___________ );

test(1, 'A', 10.1 );
test(2, 'B');
return 0;
}
void test(int a, char b, double c)
{
cout<include
using namespace std;
class Con
{
char ID;
public:
Con(): ID('A'){ cout<<1; }
Con(char ID): ID(ID){ cout<<2;}
Con(Con& c): ID(c.getID()){ cout<<3;}
char getID()const{ return ID;}
};
void show(Con c){ cout<
{
Con c1;
show(c1);
Con c2('B');
show(c2);
return 0;
}
执行上面程序的输出是___________。
（11）有如下程序：
#include
using namespace std;
class ONE
{
public:
virtual void f() { cout << "1"; }
};
class TWO : public ONE
{
public:
TWO() { cout << "2"; }
};
class THREE : public TWO
{
public:
virtual void f() { TWO::f(); cout << "3"; }
};
int main()
{
ONE aa, *p;
TWO bb;
THREE cc;
p = &cc;
p->f();
return 0;
}
执行上面程序的输出是___________。
（12）有如下程序：
#include
using namespace std;
class PARENT
{
public:
PARENT() { cout << "PARENT"; }
};
class SON : public PARENT
{
public:
SON() { cout << "SON"; }
};
int main()
{
SON son;
PARENT *p;
p = &son;
return 0;
}
执行上面程序的输出是____
（14）下面是复数类 complex 的定义，其中重载的运算符“+”的功能是返回一个新的复数对象，其实部等于两个操作
对象实部之和，其虚部等于两个操作对象虚部之和；请补充完整：
class complex
{
double real; //实部
double imag; //虚部
public:
complex( double r, double i):real(r),imag(i){}
complex operator + (complex a)
{
return complex(___________ );
}
};
（15）已知一个函数模板定义为
template
T1 FUN(T2 n){ return n*5.0;}
若要求以 int 型数据 7 为函数实参调用该模板函数，并返回一个 double 型数据，则该调用应表示为_________。

一、选择题
（11）C） （13）B） （14）C） （15）B）
（18）B） （20）D）
（21）D） （22）B） （23）B） （24）C） （25）D）
（26）A） （27）D） （28）C） （29）D） （30）B）
（32）B） （33）D） （35）B）

二、填空题
（6）break
（7）int *p=DATA
（8）=3.5
（9）2
（10）13A23B
（11）2213
（12）PARENTSON
（14）【14】real+a.real,imag+a.imag
（15）【15】FUN(7) 或 FUN(7)

三、完善程序
1. 用指针和数组来显示Fibonacci数列。
#include
using namespace std;
int main()
{
int i,fibon[10]={0,1,1,2,3,5,8,12,21,34},*pfib1,*pfib2;
pfib1=pfib2=__________;
cout<<"使用数组显示Fibonacci数列"<bon+i)<<'\t'<<_____________<
______________ input() //成员函数中访问类中的数据成员
{
cout<<"请输入矩形的长和宽:";
cin>>a>>b;
}
void Rectangle::perimeter()//注意类名不可省
{
cout<<"其周长为:"<<(a+b)*2<