全国计算机等级考试二级C笔试试题.docx

2021年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〕要建立文件流并翻开当前目录下的文件用于输入，以下语句中错误的选项是
    A〕ifstream fin=ifstream.open〔“〞〕；
    B〕ifstream*fir.=new ifstream〔“〞〕；
    C〕ifstream fin; fin.open〔“〞〕；
    D〕ifstream *fin=new ifstream〔 〕；fin一>open〔“〞〕；   
 〔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>

2021年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〕2021var B〕goto
C〕test-2021 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〕::运算符不能重载
B〕类型转换运算