2023年全国计算机等级考试二级C++笔试试题.doc

2023年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<<a.publicData <<endl ;
    B）cout<<a.privateData <<endl ;
    C）cout<<b.publicData <<endl ;
    D）cout<<b.privateData <<endl ;   
 （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<<i<<j<<endl;
    }
    运营时的输出结果是
    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<iostream>
    #include<cstring>
    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<<strien （x .Geta（））+y. Getb（）+endl;
    return 0;
    }
    运营时的输出结果是
    A）12
    B）16
    C）14
    D）11   
 （28）有如下程序：
    #include<iostream>
    #include<cstring>
    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<<a;}
    int  Geta（）{return a;}
    };
    int main（）{
    XCF dl（5），d7 （dl）；
    XCF *pd=new XCF（8）；
    cout<<pd一>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<iostream>
    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;}
    YY （int  m,   int  n）：XX （m），yy（n）{cout<<yy;}
    };
    下列选项中，输出结果为A0的语句是
    A）YY y1（0,0）;
    B）YY y2（1）;
    C）YY  y3（0）;
    D）YY  y4;   
 （32）有如下程序：
    #include<iostream>
    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<iostream>
    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<<setfill（'*’）<<123<<setw（9）<<321;
    B）cout<<setfill（‘*’）<<setw（6）<<left<<123<<setw（6）<<right<<321;
    C）cout<<123<<setfill（‘*’）<<setw（6）<<321;
    D）cout<<setfill（‘*’）<<SetW（9）<<left<<123<<321;   
 （35）有如下程序：
    #include<iostream>
    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<<x<<y<<z;
    执行这个程序段的输出是【6】。   
 （7）有如下程序段：
    fer（int i=1; i<=50;i++）{
    if（i%3 != 0）
    continue;
    else
    if（i%5!=0）
    continue;
    tout<<i<<“，”；
    }
    执行这个程序段的输出是【7】。   
 （8）有如下程序段：
    Char  c [20]=“examination”；
    c[4]=0;
    cout<<c<<endl;
    执行这个程序段的输出是【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<iostream>
    using namespace std;
    class Monitor{
    public:
    Monitor（char t）：type （t）{}
    void print（ ） const
    {cout<<“The type of monitor is”<<type<<endl;}
    private:
    char type;
    };
    class Computer{
    public:
    Computer（int i，char c）： 【11】{}
    void Print（）const
    {cout<<“The computer is”<<id<<endl;mon.Print（）；}
    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 <iostream>
    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 {return “Dog”；}
    char* getVoice （ ） const {return “Woof”}
    };
    void type（Animal& a） {cout<<a.getType（）；}
    void speak（Animal a） {cout<<a.getVoice（）；}
    int main（ ） {
    Dog d; type （d）；cout<<“ speak”；speak（d）；cout<<endi;
    return 0;
    }
    运营时的输出结果是【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<class Type>  //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<class Type>
    【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<Type>

2023年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）2023var B）goto
C）test-2023 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 T1, class T2> class A;
B）template <class T1, typename T2> class A;
C）template <typename T1, class T2> class A;
D）template <typename T1, T2> class A;
（26）下列关于C++流的描述中，错误的是（ ）。
A）cout>>'A'表达式可输出字符A
B）eof()函数可以检测是否到达文献尾
C）对磁盘文献进行流操作时，必须包含头文献fstream
D）以ios_base::out模式打开的文献不存在时，将自动建立一个新文献
（27）有如下程序：
# include <iostream>
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<<t1.getCount()<<endl;
return 0;
}
运营时的输出结果是（ ）。
A）1 B）2 C）3 D）运营时犯错
（28）有如下程序：
# include <iostream>
using namespace std;
class A {
public:
A(int i) : r1(i) {}
void print() {cout<<'E'<<r1<<'-';}
void print() const {cout<<'C'<<r1*r1<<'-';}

pivate:
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 <iostream>
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 <iostream>
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 <iostream>
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
（32）有如下程序：
# include <iostream>
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<<p.getType()<<": "<<p.getName()<<endl;
}
int main(){
Book book("精彩人生");
showPublication(book);
return 0;
}
运营时的输出结果是（ ）。
A）未知类型：未知名称 B）未知类型：精彩人生
C）书：未知名称 D）书：精彩人生
（33）下列关于运算符重载的描述中，错误的是（ ）。
A）::运算符