09年3月-10年9月全国计算机等级考试二级C++ 笔试试题及答案

2009年3月计算机等级考试二级C++真题及参考答案一、选择题（每小题2分，共70分）

（11）对C++编译器区分重载函数无任何意义的信息是 A）参数类型

B）参数个数

C）返回值类型

D）常成员函数关键字coast

（12）有如下类定义和变量定义：

class A{

publie:

A（）{data=0;}

~A（）{}

int GetData （） coast { return data;}

void SetData（int n） {data=n;}

private:

int data;

};

ccnst A a;

A b;

下列函数调用中错误的是

A）a .GetData（）；

B）a .SetData（10）；

C）b .GetData（）；

D）b .SetData（10）；

（13）有如下类定义和变量定义：

class Parents{

public:

int publicuata;

private:

int privateData;

};

class ChildA:public Parents{/*类体略*/};

class ChildB:private Parents{/*类体略*/）； ChildA a;

ChildBb;

下列语句中正确的是

A）cout<

B）cout<

C）cout<

D）cout<

（14）运算符重载时不需要保持的性质是

A）操作数个数

B）操作数类型

C）优先级

D）结合性

（15）下列关于函数模板的描述中，错误的是

A）从模板实参表和从模板函数实参表获得信息矛盾时，以模板实参的信息为准

B）对于常规参数所对应的模板实参，任何情况下都不能省略

C）虚拟类型参数没有出现在模板函数的形参表中时，不能省略模板实参

D）模板参数表不能为空

（16）要建立文件流并打开当前目录下的文件file.dat用于输入，下列语句中错误的是 A）ifstream fin=ifstream.open（“file.dat”）；

B）ifstream*fir.=new ifstream（“file.dat”）；

C）ifstream fin; fin.open（“file.dat”）；

D）ifstream *fin=new ifstream（）；fin一>open（“file.dat”）；

（17）下列描述中，不属于面向对象思想主要特征的是

A）封装性

B）跨平台性

C）继承性

D）多态性

（18）有如下程序段：

Tnt i=4;int j=l;

int main（）{

int i=8，j=i;

cout<

}

运行时的输出结果是

A）44

B）41

C）88

D）81

（19）有如下程序段：

int i=5;

while（int i=0）{cout《'*';i--;}

运行时输出“*”的个数是

A）0

B）1

C）5

D）无穷

（20）己知有数组定义

char a[3][4];

下列表达式中错误的是

A）a[2]=“WIN”

B）strcpy（a[2]，“WIN”）

C）a [2][3]='W'

D）a[0][1]=a[0][1]

（21）已知函数fun的原型为

int fun（int,int,int）；

下列重载函数原型中错误的是

A）char fun（int,int）；

B）double fun（int,int,double）；

C）int fun（int,char*）；

D）float fun （int, int, int）；

（22）建立一个类对象时，系统自动调用

A）析构函数

B）构造函数

C）静态函数

D）友元函数

（23）通过派生类的对象可直接访问其

A）公有继承基类的公有成员

B）公有继承基类的私有成员

C）私有继承基类的公有成员

D）私有继承基类的私有成员

（24）己知表达式++a中的“++”是作为成员函数重载的运算符，则与十+a等效的运算符函数调用形式为

A）a .orerator++（1）

B）operator++（a）

C）operator++（a，l）

D）a.operator++（）

（25）在定义一个类模板时，模板形参表是用一对括号括起来的，所采用的括号是

A）（）

B）[ ]

C）< >

D）{ }

（26）当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的默认打开方式为

A）ios_base::in

B）ios_base::in|ios_base::out

C）ios_base::out

D）ios_base::in&ios_base::out

（27）有如下程序：

#include

#include

using namespace std;

class XCD{

char* a;

int b;

public:

XCD（char* aa, int bb）{

a=new char[strlen（aa）+1];

strcpty（a,aa）；

b=bb;

}

Char* Geta （）{return a;）

int Getb（）{ return b;}

};

int main（）{

char *pl=“abcd”，*p2=“weirong”；

int dl=6, d2=8;

XCD x（pl,dl），Y（p2，d2）；

cout<

return 0;

}

运行时的输出结果是

A）12

B）16

C）14

D）11

（28）有如下程序：

#include

#include

using namespace std;

class XCF{

int a;

public:

XCF（int aa=0）：a （aa）{cout<<“1”；}

XCF（XCF& x）{a=x .a; cout<<“2”；）

~XCF（）{cout<

int Geta（）{return a;}

};

int main（）{

XCF dl（5），d7 （dl）；

XCF *pd=new XCF（8）；

cout<Geta（）；

delete pd;

return 0;

}

运行时的输出结果是

A）121SS88

B）12188SS

C）12185

D）128512

（29）已知类MyClass声明如下：

class MyClass{

int n;

public;

MyClass（int k）：n（k）{}

int getValue（）const{return n;}

};

在下列数组定义中正确的是

A）MyClass x1[2];

B）MyClass x2[2]={new MyClass（1），new MyClass（2）};

C）MyClass *x3[2];

D）MyClass *x4[2]={MyClass（1），MyClass（2）}; （30）有如下程序：

#include

using namespace std;

class AA{

lilt k;

protected:

int n;

void setK（int k）{ this->k=k;}

public:

void setN（int n）{ this->n=n;}

};

class BB: public }{/*类体略*/};

int main（）{

BB x_ ; //1

x .n=1; //2

x.setN （2）； //3

x.k=3; //4

x .setK（4）；

return 0;

}

在标注号码的四条语句中正确的是

A）1

B）2

C）3

D）4

（31）有如下类定义：

class XX{

int xx;

public:

XX（）：xx（0）{cout<<' A';}

XX（int n）：xx （ n）{tout<<' B';}

};

Class YY:public XX{

Int yy;

public:

YY（）：yy （ 0）{cout+yy;}

YY（int n）：XX（n+1），yy（n）{cout<

YY （int m, int n）：XX （m），yy（n）{cout<

下列选项中，输出结果为A0的语句是

A）YY y1（0,0）;

B）YY y2（1）;

C）YY y3（0）;

D）YY y4;

（32）有如下程序：

#include

Using namespace std;

class A{

public:

virtual void f（）{cout+1;}

void g（）{cout<<2;}

};

class B:public A{

public:

virtual void f（）{cout<<3;}

void g（）{ecut<<4;}

};

void show（A &a）{a.f（）；a.g（）；}

int main（）{

B b;

show（b）；

return 0;

}

运行时的输出结果是

A）12

B）34

C）14

D）32

（33）有如下程序：

#include

using namespace std;

class Pair{

int m;

int n;

public:

Pair（int i，int j）：m（i），n（j）{}

boot operator >（pair p）const; //须在类体外给出定义

}；

int main（）{

Pair Al（3,4），p2（4,3）；p3（4,5）；

Cout<<（pl>p2）<<（P2>P1）<<（p2>p3）<<（p3>p2）；

return 0;

}

运算符函数。operator>的功能是比较两个Pair对象的大小，当左边对象大时，返回true，否则返回false。比较规则是首先比较两对象的m成员，m大者为大；当m相等时比较n，n 大者为大。程序输出0101，下列对运算符重载函数的正确定义是

A）bool Pair::operator>（Pair p）const

{if （m!=p.m） return m>p.m; return n>p.n;}

B）bool Pair:;operator>（Pair p）

{if （m!=p.m） return m>p.m; return n>p.n;}

C）bool Pair::operator>（Pair p）const

{if （m>p.m） return true; return n>p.n;}

D）bool Pair:;operator>（Pair p）

{if （m>p.m） return true; return n>p.n;}

（34）假定下列语句都是程序运行后首次执行的输出语句，其中输出结果与另外三条语句不同的语句是

A）cout<

B）cout<

C）cout<<123<

D）cout<

（35）有如下程序：

#include

using namespace std;

class ONE{

int c;

public:

ONE（）：c（0）{cout<<1;}

ONE（int n）：c （n）{cout<<2;}

};

class TWO{

ONE onel;

ONE one2;

public:

TWO（int m）：one2（m）{cout<<3;}

};

int main（）t

TWO t（4）

return 0

}

运行时的输出结果是

A）3

B）23

C）123

D）213

二、填空题（每空2分，共30分）

（6）有如下程序段：

int x=1,Y=2,z=3;

x=x^z;

y=y^z;

z=x^y;

cout<

执行这个程序段的输出是【6】。

（7）有如下程序段：

fer（int i=1; i<=50;i++）{

if（i%3 != 0）

continue;

else

if（i%5!=0）

continue;

tout<

}

执行这个程序段的输出是【7】。

（8）有如下程序段：

Char c [20]=“examination”；

c[4]=0;

cout<

执行这个程序段的输出是【8】。

（9）下面的函数利用递归实现了求1+2+3+……+n的功能：

int sum（int n）{

if（n==0）

return 0;

else

return n+sum（n-1）；

}

在执行sum（10）的过程中，递归调用sum函数的次数是【9】。（10）非成员函数应该声明为类【10】函数才能访问该类的私有成员。（11）有如下程序：

#include

using namespace std;

class Monitor{

public:

Monitor（char t）：type （t）{}

void print（） const

{cout<<“The type of monitor is”<

private:

char type;

};

class Computer{

public:

Computer（int i，char c）：【11】{}

void Print（）const

{cout<<“The computer is”<

private:

int id;

Monitor mon;

};

const Computer myComputer（101,'B‘）；

myComputer .Print（）；

return 0;

}

请将程序补充完整，使程序在运行时输出：

The computer is 101

'The type of monitor i.s 8

（12）有如下程序：

#include

using namespace std

class Animal{

public:

virtual char* getType（）const { return “Animal”；}

virtual char* getVoice（）const { return “Voice”；}

};

Class Dog : public Animal {

public:

char* getType （） const {retur n “Dog”；}

char* getVoice （）const {return “Woof”}

};

void type（Animal& a） {cout<

void speak（Animal a） {cout<

int main（） {

Dog d; type （d）；cout<<“ speak”；speak（d）；cout<

}

运行时的输出结果是【12】。

（13）补充完整下面的类定义：

const double PI=3 .14;

class Circle{ //圆形物体的抽象基类

protected:

double r; //半径

public:

Circle（double radius=0）：r（radius）{}

【13】；//计算圆形物体表面积的纯虚函数声明

};

class Cylinder:public Circle { //圆柱体类

double h; //高度

public:

Cylindr（double radius=0, doubli height=0）：

Circle（radius），h （height）{}

Virtual double Area（） { //计算圆柱体的表面积

return 2*PI*r*（r+h）；

}

};

（14）补充完整下面的类定义：

class XCH{

char* a;

public:

XCH（char* as） { //构造函数

a=new char[strlen（aa）+1];

strcpy（a,aa）；

}

XCH& operator=（const XCH& x） //重载赋值函数

Delele []a;

A=new char[strlen（x.a）+l];

strcpy（a, x .a）

【14】；

}

~XCH（） {delete []a;}

};

（15）补充完整下面的模板定义：

template //Type为类型参数

class Xtwo{ //由两个Type类型的数据成员构成的模板类

Type a;

Type b;

public:

Xtwe（Type aa=0, Type bb=0）：a（aa），b（bb）{}

int Ccmpare （）{//比较a和b的大小

if （a>b）returm 1;

else if（a==b） return 0;

else return -1;

}

Type Snm（） {return a+b;} //返回a和b之和

Type Mult（）； //函数声明，返回a和b之乘积

｝；

Template

【15】：：Mult（）{return a*b;} //Mult 函数的类外定义

参考答案

一、选择题：

（11）D （12）B （13）A （14）B （15）B （16）A （17）B （18）C （19) A （20）D （21）D （22）B （23）A （24）B （25）C （26）B （27）A （28）B （29）C （30）B （31）D （32）D （33）

C （34）C （35）B

二、填空题

（6）213 （7）15,30,45 （8）examination（9）10 （10）友元（11）id（i），mom（c）（12）Dog speak Woof （13）Virtual double Area（）{ return PI *r*r} （14）return *a （15）Xwo

2009年9月二级C++笔试试卷

（11）已知函数FA调用FB，若要把这两个函数定义在同一个文件中，则（）。

A）FA必须定义在FB之前

B）FB必须定义在FA之前

C）若FA定义在FB之后，则FA的原型必须出现在FB的定义之前

D）若FB定义在FA之后，则FB的原型必须出现在FA的定义之前

（12）有如下两个类定义：

class AA{};

class BB {

AA v1,*v2;

BB v3;

int *v4;

};

其中有一个成员变量的定义是错误的，这个变量是（）。

A）v1 B）v2 C）v3 D）v4

（13）有如下类定义：

class XX {

int xdata;

public:

XX(int n=0) : xdata(n){}

};

class YY : public XX {

int ydata;

public:

YY(int m=0, int n=0) : XX(m), ydata(n){}

};

YY类的对象包含的数据成员的个数是（）。

A）1 B）2 C）3 D）4

（14）下列关于运算符函数的描述中，错误的是（）。

A）运算符函数的名称总是以operator为前缀

B）运算符函数的参数可以是对象

C）运算符函数只能定义为类的成员函数

D）在表达式中使用重载的运算符相当于调用运算符重载函数

（15）下列关于模板形参的描述中，错误的是（）。

A）模板形参表必须在关键字template之后

B）模板形参表必须用括弧()括起来

C)可以用class修饰模板形参

D）可以用typename修饰模板形参

（16）在下列枚举符号中，用来表示“相对于当前位置”文件定位方式的是（）。A）ios_base::cur B）ios_base::beg

C）ios_base::out D）ios_base::end

（17）下列字符串中可以用作C++标识符的是（）。

A）2009var B）goto

C）test-2009 D）_123

（18）下列枚举类型的定义中，包含枚举值3的是（）。

A）enum test {RED, YELLOW, BLUE, BLACK};

B）enum test {RED, YELLOW=4, BLUE, BLACK};

C）enum test {RED=-1，YELLOW, BLUE, BLACK};

D）enum test {RED, YELLOW=6, BLUE, BLACK};

（19）有如下程序段：

int i=1;

while(1) {

i++;

if(i==10) break;

if(i%2==0) cout<<'*';

}

}

执行这个程序段输出字符*的个数是（）。

A）10 B）3 C）4 D）5

（20）已知数组arr的定义如下：

int arr[5]={1,2,3,4,5};

下列语句中输出结果不是2的是（）。

A）cout << *arr+1 << endl; B）cout << * (arr+1) << endl;

C）cout << arr[1] << endl; D）cout << *art << endl;

（21）计算斐波那契数列第n项的函数定义如下：

int fib(int n){

if(n==0) return 1;

else if(n==1) return 2;

else return fib(n-1)+fib(n-2);

}

若执行函数调用表达式fib(2)，函数fib被调用的次数是（）。

A）1 B）2 C）3 D）4

22）Sample是一个类，执行下面语句后，调用Sample类的构造函数的次数是（）。Sample a[2], *P = new Sample;

A）0 B）1 C）2 D）3

（23）下列关于虚基类的描述中，错误的是（）。

A）使用虚基类可以消除由多继承产生的二义性

B）构造派生类对象时，虚基类的构造函数只被调用一次

C）声明“class B : virtual public A”说明类B为虚基类

D）建立派生类对象时，首先调用虚基类的构造函数

（24）将运算符重载为类成员函数时，其参数表中没有参数，说明该运算符是（）。A）不合法的运算符B）一元运算符

C）无操作数的运算符D）二元运算符

（25）有如下模板声明：

template < typename T1, typename T2> class A;

下列声明中，与上述声明不等价的是（）。

A）template class A;

B）template class A;

C）template class A;

D）template class A;

（26）下列关于C++流的描述中，错误的是（）。

A）cout>>'A'表达式可输出字符A

B）eof()函数可以检测是否到达文件尾

C）对磁盘文件进行流操作时，必须包含头文件fstream

D）以ios_base::out模式打开的文件不存在时，将自动建立一个新文件

（27）有如下程序：

# include

using namespace std;

class Toy {

public:

Toy(char* _n){ strcpy(name, _n); count++;}

~Toy() { count--;}

char* GetName(){ return name; }

static int getCount(){ return count; }

private:

char name[10];

static int count;

};

int Toy::count=0;

int main(){

Toy t1("Snoopy"), t2("Mickey"), t3("Barbie"); cout<

return 0;

}

运行时的输出结果是（）。

A）1 B）2 C）3 D）运行时出错

（28）有如下程序：

# include

using namespace std;

class A {

public:

A(int i) : r1(i) {}

void print() {cout<<'E'<

void print() const {cout<<'C'<

int r1;

};

int main(){ 日

A a1(2); const A a2(4);

a1.print(); a2.print();

return 0;

}

运行时的输出结果是（）。

A）运行时出错B）E2-C16- C）C4-C16- D）E2-E4- （29）有如下程序：

# include

using namespace std;

class Name{

char name[20];

public:

Name(){

strcpy(name, ""); cout<<'?';

}

Name(char *fname){

strcpy(name,fname); cout<<'?';

}

};

int main(){

Name names[3]={Name("张三"), Name("李四")}; return 0;

}

运行此程序输出符号?的个数是（）。

A）0 B）1 C）2 D）3

（30）有如下程序：

# include

using namespace std;

class AA{

public:

AA(){ cout<<'1'; }

};

class BB: public AA{

int k;

public:

BB() : k(0) { cout<<'2'; }

BB(int n) : k(n) { cout<<'3'; }

};

int main(){

BB b(4), c;

return 0;

}

运行时的输出结果是（）。

A）1312 B）132 C）32 D）1412

（31）有如下程序：

# include

using namespace std;

class C1{

public:

~C1(){ cout<<1; }

};

class C2: public C1{

public:

~C2(){ cout<<2; }

};

int main(){

C2 cb2;

C1 *cb1;

return 0;

}

运行时的输出结果是（）。

A）121 B）21 C）211 D）12

# include

using namespace std;

class Publication{ //出版物类

char name[30];

public:

Publication(char *name="未知名称"){

strcpy(this->name,name);

}

const char * getName()const{ return name; }

virtual const char * getType()const{ return "未知类型";} };

class Book: public Publication{ //书类

public:

Book(char *name): Publication(name){}

virtual const char * getType()const{ return "书";}

};

void showPublication( Publication &p){

cout<

}

int main(){

Book book("精彩人生");

showPublication(book);

return 0;

}

运行时的输出结果是（）。

A）未知类型：未知名称B）未知类型：精彩人生

C）书：未知名称D）书：精彩人生

（33）下列关于运算符重载的描述中，错误的是（）。A）::运算符不能重载

B）类型转换运算符只能作为成员函数重载

C）将运算符作为非成员函数重载时必须定义为友元

D）重载[ ]运算符应完成“下标访问”操作

（34）有如下程序：

# include

# include

using namespace std;

int main(){

int s[]={123, 234};

cout<

for(int i=0; i<2; i++){ cout<

return 0;

}

运行时的输出结果是（）。

A）123 B）***123 C）***123 D）***123

234 234 ***234 234***

ciass A {

char *a;

public:

A() : a(0){}

A(char *aa){ //把aa所指字符串拷贝到a所指向的存储空间

a=__________;

strcpy(a,aa);

}

~A() (delete []a;}

};

横线处应填写的表达式是（）。

A）new char[strlen(aa)+1] B）char[strlen(aa)+1]

C）char[strlen(aa)] D）new char[sizeof(aa)-1]

二、填空题（每空2分，共30分）

（6）若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为【6】。（7）有如下循环语句：

for(int i=50; i>20; i-=2) cout<

运行时循环体的执行次数是【7】次。

（8）利用表达式a[i]可以访问int型数组a中下标为i的元素。在执行了语句int *p=a;后，利用指针p也可

访问该元素，相应的表达式是【8】。

（9）下面是一个递归函数，其功能是使数组中的元素反序排列。请将函数补充完整。

void reverse(int *a, int size){

if(size<2) return;

int k=a[0];

a[0]=a[size-1];

a[size-1]=k;

reverse(a+l, 【9】);

}

（10）类Sample的构造函数将形参data赋值给数据成员data。请将类定义补充完整。class Sample{

public:

Sample(int data=0);

private:

int data;

};

Sample::Sample(int data){

【10】

}

（11）有如下类定义：

class Sample{

public:

Sample();

~Sample();

private:

static int data;

};

将静态数据成员data初始化为0的语句是【11】。

（12）“图形”类Shape中定义了纯虚函数CalArea()，“三角形”类Triangle继承了类Shape，请将Triangle

类中的CalArea函数补充完整。

class Shape{

public:

virtual int CalArea()=0;

};

class Triangle: public Shape{

public:

Triangle(int s, int h) : side(s), height(h){}

【12】。{ return side * height/2;}

private:

int side;

int height;

};

（13）有如下程序：

# include

using namespace std;

class GrandChild{

public:

GrandChild(){ strcpy(name,"Unknown"); }

const char * getName() const { return name;}

virtual char * getAddress() const=0;

private:

char name[20];

};

class GrandSon : public GrandChild{

public:

GrandSon(char *name){}

char * getAddress() const { return "Shanghai"; }

};

int main(){

GrandChild *gs=new GrandSon ("Feifei");

cout<getName()<<"住在"<getAddress()<

delete gs;

return 0;

}

运行时的输出结果是【13】。

（14）如下程序定义了“单词”类W ord，类中重载了<运算符，用于比较“单词”的大小，返回相应的逻

辑值。程序的输出结果为：After Sorting：Happy W elcome，请将程序补充完整。

# include

# include

using namespace std;

class W ord{

public:

W ord(string s) : str(s){}

string getStr(){ return str; }

bool operator < (W ord w) const {return(str

friend ostream& operator<<(ostream& output, const W ord &w)

{ output<

private:

string str;

};

int main(){

W ord w1("Happy"),w2("W elcome");

cout<<"After sorting: ";

if(w1

else cout<

return 0;

}

（15）请将下列模板类Data补充完整。

template

class Data{

public:

void put(T v) { val=v; }

【15】get() //返回数据成员val的值，返回类型不加转换

{ return val; }

private:

T val;

};

2009年9月二级C++笔试试卷参考答案

一、选择题

（1）C）（2）B）（3）D）（4）A）（5）B）（6）A）（7）C）（8）B）（9）C）（10）D）

（11）D）（12）C）（13）B）（14）C）（15）B（16）A）（17）D）（18）A）（19）C）（20）D）

（21）B）（22）D）（23）C）（24）B）（25）D（26）A）（27）C）（28）B）（29）D）（30）A）

（31）B）（32）D）（33）C）（34）B）（35）A）

二、填空题

（6）double型（7）15 （8）*(p+i)（9）size-2 （10）this->data=data（11）int Sample ::data=0（12）int CalArea(size,height)（13）Unknown住在Shanghai （14）bool operator < (Word w) （15）T

2010年3月计算机等级考试二级C++笔试试题(文字版)

一、选择题(每小题2分，共70分)

(11)下列关于函数的描述中，错误的是

A)函数可以没有返回值

B)函数可以没有参数

C)函数可以是一个类的成员

D)函数不能被定义为模板

(12)若MyClass是一个类名，且有如下语句序列

MyClass c1,*c2;

MyClass *c3=new MyClass;

MyClass &c4=c1;

上面的语句序列所定义的类对象的个数是

A)1

B)2

C)3

D)4

(13)下列关于继承方式的描述中，错误的是

A)如果不显式地指定继承方式，缺省的继承方式是私有(private)

B)采用公有继承方式时，基类中的公有成员在派生类中仍然是公有成员

C)采用保护继承方式时，基类中的保护成员在派生类中仍然是保护成员

D)采用私有继承方式时，基类中的私有成员在派生类中仍然是私有成员

(14)将前缀运算符“--”重载为非成员函数，下列原型中，能正确用于类中说明的是

A)Decr& operator --(int);

B)Decr operator --( Decr&,int);

C)friend Decr& operator --(Decr&);

D)frlend Decr operator --(Decr&,int);

(15)若MyTemp是一个只有一个虚拟类型参数的类模板，且有如下语句序列MyTempp2;

MyTempp3[2];

编译系统在处理上面的语句序列时，所生成的模板MyTemp的实例的个数是

A)1

B)2

C)3

D)0

(16)在C++中，cin是个

A)类

B)对象

C)模板

D)函数

(17)在下列字符中，不允许作为C++标识符的是

A)b

B)B

C)_

D)2

(18)下列叙述中，错误的是

A)false是一个逻辑型常量

B)"b"是一个字符型常量

C)365是一个int常量

D)3.1415926是一个double常量

(19)若x和y是程序中的两个整型变量，则下列if语句中正确的是

A)if(x==0) y=1; else y=2;

B)if(x==0) then y=1 else y=2;

C)if(x==0) y=1 else y=2;

D)if x==0 y=1; else y=2;

(20)要定义整型数组x，使之包括初值为O的三个元素，下列语句中错误的是

A)int x[3]={0,0,0};

B)int x[]={0};

C)static int x[3]={0};

D)int x[]={0,0,0};

(21)关于函数中的<返回类型>，下列表述中错误的是

A)<返回类型>中有可能包含关键字int

B)<返回类型>中有可能包含自定义标识符

C)<返回类型>中有可能包含字符*

D)<返回类型>中可能包含[]

(22)要定义一个引用变量p，使之引用类MyClass的一个对象，正确的定义语句是

A)MyClass p=MyClass;

B)MyClass p=new MyClass;

C)MyClass &p=new MyClass;

D) MyClass a，&p=a;

(23)有如下两个类定义

class XX{

private:

double x1;

protected:

double x2;

public:

double x3;

};

class YY:protected XX{

private:

double y1;

protected:

double y2;

public:

double y3;

};

在类YY中保护成员变量的个数是

A)1

B)2

C)3

D)4

(24)下列关于运算符重载的描述中，错误的是

A)可以通过运算符重载在C++中创建新的运算符

B)赋值运算符只能重载为成员函数

C)运算符函数重载为类的成员函数时，第一操作数是该类对象