第六章 C++类和对象

第1题

 以下程序的执行结果是（）。

#include<iostream.h>
class TestClass2
{
public:
    TestClass2(){};
    TestClass2(int i,int j);
    void printb();
private:
    int a,b;
};
class TestClass1
{
public:
    TestClass1(){}
    TestClass1(int i,int j);
    void printa();
private:
    TestClass2 c;
};
TestClass1::TestClass1(int i,int j):c(i,j)
{}
void TestClass1::printa()
{
    c.printb();
}
TestClass2::TestClass2(int i,int j)
{
    a=i;
    b=j;
}
void TestClass2::printb()
{
    cout<<"a="<<a<<" "<<"b="<<b<<endl;
}
void main()
{
    TestClass1 m(7,9);
    m.printa();
}

第2题

下面程序的输出结果为（）。

#include<iostream.h>
class TestClass
{
public:
    TestClass(){val++;};
    static int val;
};
int TestClass::val=0;
void main()
{
    TestClass cs1;
    cout<<cs1.val<<"";
    TestClass cs2;
    TestClass cs3,cs4;
    cout<<cs2.val<<endl;
}

第3题

下面程序的运行结果是（）。

#include<iostream>
using namespace std;
class TestClass
{
    static int n;
public:
    TestClass()
    {
        n++;
    }
    static int test()
    {
        for(int i=0;i<4;i++)n++;
        return n;
    }
};
int TestClass::n=0;
int main()
{
    cout<<TestClass::test()<<" ";
    TestClass c1,c2;
    cout<<TestClass::test()<<endl;
    return 0;
}

第4题

下列关于成员函数特征的描述中，错误的是（）。

第5题

有如下程序，执行后的输出结果是（）。

#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;
}

第6题

假定MyClass为一个类，那么下列的函数说明中，（）为该类的析构函数。

第7题

下列情况中，不会调用拷贝构造函数的是（）。

第8题

类MyClass的定义如下，若要对value赋值，则下面语句正确的是（）。

class MyClass
{
public:
    MyClass(){}
    MyClass(int i){value=new int(i);}
    int*value;
};

第9题

若有如下程序，程序运行后的输出结果是（）。

#include<iostream>
using namespace std;
int s=0;
class sample
{
    static int n;
public:
    sample(int i)
    {
        n=i;
    }
    static void add()
    {
        s+=n;
    }
};
int sample::n=0;
int main()
{
    sample a(2),b(5);
    sample::add();
    cout<<s<<endl;
    return 0;
}

第10题

有如下程序，该程序运行后的输出结果是（）。

#include<iostream>
using namespace std;
class sample
{
private:
    int x,y;
public:
    sample(int i,int j)
    {
        x=i;
        y=j;
    }
    void disp()
    {
        cout<<"disp1"<<endl;
    }
    void disp()const
    {
        cout<<"disp2"<<endl;
    }
};
int main()
{
    const sample a(1,2);
    a.disp();
    return 0;
}

第11题

有如下类的定义，横线处的语句是（）。

class TestClass
{
    ______ int x,y;
public:
    TestClass(int a=0,int b=0)
    {
        x=a;
        y=b;
    }
    static void change()
    {
        y=10;
        x=10;
    }
}

第12题

在函数中，可以用auto、extern、register和static这四个关键字中的一个来说明变量的存储类型，如果不说明存储类型，则默认的存储类型是（）。

第13题

若要把函数void fun()定义为TestClass的友元函数，则应该在类TestClass的定义中加入的语句是（）。

第14题

假定MyClass为一个类，则该类的拷贝构造函数的声明语句为（）。

第15题

关于静态成员的描述中，错误的是（）。

第16题

下列关于构造函数的描述中，错误的是（）。

第17题

下面关于构造函数和析构函数的描述中，错误的是（）。

第18题

下面程序的输出结果是（）。

#include<iostream>
#include<math.h>
using namespace std;
class point
{
private:
    double x;
    double y;
public:
    point(double a,double b)
    {
        x=a;
        y=b;
    }
    friend double distances(point a,point b);
};
double distances(point a,point b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int main()
{
    point p1(1,2);
    point p2(5,2);
    cout<<distances(p1,p2)<<endl;
    return 0;
}

第19题

有以下程序，执行后的输出结果是（）。

#include<iostream>
using namespace std;
class R
{
public:
    R(int r1,int r2)
    {
        R1=r1;
        R2=r2;
    }
    void print();
    void print()const;
private:
    int R1,R2;
};
void R::print()
{
    cout<<R1<<","<<R2<<endl;
}
void R::print()const
{
    cout<<R1<<","<<R2<<endl;
}
int main()
{
    R a(5,4);
    const R b(20,52);
    a.print();
    b.print();
    return 0;
}

第20题

下列关于this指针的叙述中，正确的是（）。

第21题

关于this指针的说法不正确的是（）。

第22题

有如下程序，若程序的输出结果是：123，则程序中横线处的语句是（）。

#include<iostream>
using namespace std;
int i=1;
class Fun
{
public:
    static int i;
    int value(){ return i-1;}
    int value()const{return i+1;}
};
int Fun::i=2;
int main()
{
    int i=3;
    Fun fun1;
    const Fun fun2;
    ________;
    return 0;
}

第23题

下列关于对象概念的描述中，不正确的是（）。

第24题

静态数据成员在（）进行初始化。

第25题

在C++中，实现封装性需借助于（）。

第26题

下列关于类和对象的叙述中，错误的是（）。

第27题

有以下程序，在横线应添加（）。

#include<iostream>
using namespace std;
class TestClass
{
public:
    TestClass (int n){number=n;}
    ________//拷贝构造函数
    ~TestClass (){}
private:
    int number;
};
TestClass fun(TestClass p)
{
    TestClass temp(p);
    return temp;
}
int main()
{
    TestClass obj1(10),obj2(0);
    TestClass obj3(obj1);
    obj2=fun(obj3);
    return 0;
}

第28题

下述静态数据成员的特征中，错误的是（）。

第29题

类的析构函数的作用是（）。

第30题

类MyClass的定义如下：

class MyClass
{
public:
    MyClass(){value=0;}
    SetVariable(int i){value=i;}
private:
    int value;
};

则对下列语句序列正确的描述是（）。

第31题

有如下程序，运行时输出的结果是（）。

#include<iostream>
using namespace std;
class A{
public:
    static int a;
    void init(){a=1;}
    A(int a=2){init(); a++;}
};
int A::a=0;
A obj;
int main(){
    cout<<obj.a;
    return 0;
}

第32题

（）提供了类对外部的接口，私有成员是类的内部实现，而保护成员不允许外界访问，但允许派生类的成员访问，这样既有一定的隐藏能力，又提供了开放的接口。

第33题

在下面的定义中，错误的语句是（）。

class Sample
{
public:
    Sample(int val); //①
    ~Sample();       //②
private:
    int a=2.5;       //③
    Sample();        //④
};

第34题

假定MyClass为一个类，则该类的拷贝初始化构造函数的声明语句为（）。

第35题

 下面对静态数据成员的描述中，正确的是（）。

第36题

有如下类的定义，横线处的语句是（）。

class MyClass
{
public:
    MyClass(int a=0,int b=0)
    {
        X=a;
        Y=b;
    }
    void Change() const
    {
        X=10;
        Y=10;
    }
private:
    ______ int X,Y;
};

第37题

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

第38题

下列关于this指针的叙述中，正确的是（）。

第39题

有如下程序，执行上面程序的过程中，构造函数 TestClass（） 和 TestClass (const TestClass&x) 被调用的次数分别是（）。

#include<iostream.h>
using namespace std;
class TestClass
{
public:
    TestClass (){cout<<"default constructor\n";}
    TestClass (const TestClass &x){cout<<"copy constructor\n";}
};
TestClass userCode(TestClass b){ TestClass c(b);return c;}
int main()
{
    TestClass a,d;
    cout<<"calling userCode\n";
    d=userCode(a);
    return 0;
}

第40题

有如下程序，执行后的输出结果是（）。

#include<iostream>
using namespace std;
class TestClass
{
public:
    TestClass(int r1,int r2)
    {
        R1=r1;
        R2=r2;
    }
    void print();
    void print()const;
private:
    int R1,R2;
};
void TestClass::print()
{
    cout<<R1<<","<<R2<<endl;
}
void TestClass::print()const
{
    cout<<R1<<","<<R2<<endl;
}
int main()
{
    TestClass a(5,4);
    const TestClass b(20,52);
    b.print();
    return 0;
}

第41题

静态数据成员是为（）的数据。

第42题

有类声明： class Foo(int bar); 则Foo类的成员bar是（）。

第43题

有如下定义，其中存在语法错误的行是（）。

class Foo
{
public:
    Foo(int v): value(v) {} //①
    ~Foo() {}               //②
private:
    Foo() {}                //③
    int value=0;            //④
};

第44题

有如下定义，在标注号码的行中，能被正确编译的是（）。

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;

第45题

有类定义 class SAMPLE { int n; public: SAMPLE(int i=0){n=i;} void setValue(int n0); }; ，下列关于setValue函数的实现中，正确的是（）。

第46题

以下关键字不能用来声明类的访问权限的是（）。

第47题

下列关于类定义的说法中，正确的是（）。

第48题

如果派生类以protected方式继承基类，则原基类的protected成员和public成员在派生类中的访问属性分别是（）。

第49题

下列有关类成员的叙述中，正确的是（）。

第50题

下列运算函数中，肯定不属于类Value的成员函数的是（）。

第51题

有如下程序，运行时的输出结果是（）。 

#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];
        strcpy(a, aa);
        b=bb;
    }
    char* Geta() { return a; }
    int Getb() { return b; }
};
int main() {
    char *p1="abcd",*p2="weirong";
    int d1=6,d2=8;
    XCD x(p1,d1),y(p2,d2);
    cout<<strlen(x.Geta())+y.Getb()<<endl;
    return 0;
}

第52题

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

class AA{};
class BB {
    AA v1,*v2;
    BB v3;
    int *v4;
};

第53题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class Point
{
    int x,y;
public:
    Point(int x1=0,int y1=0):x(x1),y(y1){}
    int get(){return x+y;}
};
class Circle
{
    Point center;
    int radius;
public:
    Circle(int cx,int cy,int r):center(cx,cy),radius(r){}
    int get(){return center.get()+radius;}
};
int main()
{
    Circle c(3,4,5);
    cout<<c.get()<<endl;
    return 0;
}

第54题

 若AA为一个类，a为该类的私有整型数据成员，getA（）为该类的一个非静态公有成员函数，功能是返回a的值。如果X为该类的一个对象，要在类外访问X对象中a的值，正确的访问格式为（）。

第55题

有如下类定义，创建这个类的对象时，数据成员的初始化顺序是（）。

class MyClass{
    int b; char a; double c;
public:
    MyClass():c(0.0),b(0),a('c'){}
};

第56题

下列关于类和对象的叙述中，错误的是（）。

第57题

若有如下类声明，执行语句 MyClass a，b[2]，*p[2]; 以后，程序的输出结果是（）。

class MyClass{
public:
    MyClass(){cout<<1;}
};

第58题

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

第59题

 若MyClass是一个类名，且有如下语句序列： MyClass c1,*c2; MyClass *c3=new MyClass; MyClass &c4=c1; ，上面的语句序列所定义的类对象的个数是（）。

第60题

要定义一个引用变量p，使之引用类MyClass的一个对象，正确的定义语句是（）。

第61题

下列关于对象初始化的叙述中，正确的是（）。

第62题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class Pair {
    int m,n;
public:
    Pair(int j,int k):m(j),n(k){}
    int get(){return m;}
    int get()const {return m+n;}
};
int main() {
    Pair a(3,5);
    const Pair b(3,5);
    cout<<a.get()<<b.get();
    return 0;
}

第63题

有如下类定义，已知obj是类MyClass的对象，下列语句中违反类成员访问控制权限的是（）。

class MyClass{
    int x;
public:
    MyClass():x(0),y(0){}
    int GetX(){return x;}
    void SetX(int xx){x=xx;}
    int y;
};

第64题

有如下程序，运行时输出的结果是（）。

#include<iostream>
using namespace std;
class Point
{
    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;
}

第65题

在下列函数原型中，可以作为类AA构造函数的是（）。

第66题

有如下类定义，若执行语句 Point a(2), b[3], *c[4]; ，则Point类的构造函数被调用的次数是（）。

class Point
{
    int x,y;
public:
    Point():x(0),y(0){}
    Point(int x,int y=0):x(x),y(y){}
};

第67题

有如下程序，执行这个程序屏幕上将显示输出（）。

#include<iostream>
#include<iomanip>
using namespace std;
class MyClass{
public:
    MyClass(){cout<<'A';}
    MyClass(char c){cout<<c;}
    ~MyClass(){cout<<'B';}
};
int main() {
    MyClass p1,*p2;
    p2=new MyClass('X');
    delete p2;
    return 0;
}

第68题

有如下程序，运行时输出的结果是（）。

#include<iostream>
using namespace std;
class test{
private:
    int a;
public:
    test() {cout<<"constructor"<<endl;}
    test(int a) {cout<<a<<endl;}
    test(const test&test) {
        a=test.a;
        cout<<"copy constructor"<<endl;
    }
    ~test() {cout<<"destructor"<<endl;}
};
int main() {
    test A(3);
    return 0;
}

第69题

对于一个类定义，下列叙述中错误的是（）。

第70题

有如下程序，程序的输出结果是（）。

#include<iostream>
using namespace std;
class Part{
public:
    Part(int x=0):val(x) {cout<<val;}
    ~Part(){cout<<val;}
private:
    int val;
};
class Whole{
public:
    Whole(int x,int y,int z=0):p2(x),p1(y),val(z){cout<<val;}
    ~Whole(){cout<<val;}
private:
    Part p1,p2;
    int val;
};
int main(){
    Whole obj(1,2,3);
    return 0;
}

第71题

有如下程序，程序的输出结果是（）。

#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;
}

第72题

有如下类定义，则类MyClass的构造函数的个数是（）。

class MyClass{
    int value;
public:
    MyClass(int n): value(n) {}
    int getValue()const {return value;}
};

第73题

在C++中，编译系统自动为一个类生成缺省构造函数的条件是（）。

第74题

有如下程序，执行这个程序输出星号（*）的个数为（）。

#include<iostream>
using namespace std;
class Sample{
public:
    Sample(){}
    ~Sample(){cout<<"*";}
};
int main(){
    Sample temp[2],*pTemp[2];
    return 0;
}

第75题

 有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class MyClass{
public:
    MyClass(int i=0){cout<<1;}
    MyClass(const MyClass&x){cout<<2;}
    MyClass& operator=(const MyClass&x){cout<<3;return*this;}
    ~MyClass(){cout<<4;}
};
int main(){
    MyClass obj1(1),obj2(2),obj3(obj1);
    return 0;
}

第76题

有如下程序，运行时的输出结果是（）。

#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 d1(5), d2(d1);
    XCF *p=new XCF(8);
    cout<<p->Geta();
    delete p;
    return 0;
}

第77题

有如下程序，运行时的输出结果是（）。

#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 one1;
    ONE one2;
public:
    TWO(int m): one2(m) {cout<<3;}
};
int main() {
    TWO t(4);
    return 0;
}

第78题

 Sample是一个类，执行下面语句后，调用Sample类的构造函数的次数是（）。

Sample a[2], *p=new Sample;

第79题

有如下程序，运行时的输出结果是（）。

#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;
}

第80题

有如下程序，运行此程序输出符号？的个数是（）。

#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 name[3]={Name("张三"),Name("李四")};
    return 0;
}

第81题

有如下程序，运行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class Test{
public:
    Test(){}
    Test(const Test& t){cout<<1;}
};
Test fun(Test &u){Test t=u;return t;}
int main(){Test x,y;x=fun(y);return 0;}

第82题

若MyClass为一个类，执行 MyClass a[4],*p[5]; 语句时会自动调用该类构造函数的次数是（）。

第83题

有如下程序，运行时的输出结果是（）。-

#include<iostream>
using namespace std;
class CD{
public:
    ~CD() { cout<<"C";}
private:
    char name[80];
};
int main(){ CD a, *b, d[2];return 0;}

第84题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class XA{
    int a;
public:
    static int b;
    XA(int aa):a(aa){b++;}
    ~XA(){}
    int get(){return a;}
};
int XA::b=0;
int main(){
    XA d1(2),d2(3);
    cout<<<d1.get()+d2.get()+XA::b<<endl;
    return 0;
}

第85题

下列关于析构函数的描述中，错误的是（）。

第86题

下列关于构造函数的描述中，错误的是（）。

第87题

若PAT是一个类，则程序运行时，语句 PAT (*ad)[3]; 调用PAT的构造函数的次数是（）。

第88题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class MyClass {
public:
    MyClass () { cout << "*"; }
    MyClass (MyClass & a) { cout << "#"; }
    ~MyClass () { cout << "@"; }
};
int main(){
    MyClass a;
    Myclass b(a);
    return 0;
}

第89题

有如下程序，运行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class Monkey{
public:
    Monkey() {cout<<"M";}
    Monkey(char n) {cout<<n;}
    ~Monkey() {cout<<"Y";}
};
int main(){
    Monkey p1,*p2;
    p2=new Monkey('X');
    delete p2;
    return 0;
}

第90题

下列关于类成员对象构造函数调用顺序的叙述中，正确的是（）。

第91题

 有如下程序，运行这个程序的输出结果是（）。

#include<iostream>
#include<cstring>
using namespace std;
class MyString{
public:
    char str[80];
    MyString(const char* s){strcpy(str,s);}
    MyString& operator+=(MyString a){
        strcat(str,a.str);
        return *this;
    }
};
ostream& operator<<(ostream& s,const MyString& z){return s<<z.str;}
int main(){
    MyString x("abc"),y("cde");
    cout<<(x+=y)<<endl;
    return 0;
}

第92题

有如下头文件，在所描述的函数中，具有隐含的this指针的是（）。

int f1();
static int f2();
class MA{
public:
    int f3();
    static int f4();
};

第93题

下列程序段中包含4个函数，其中具有隐含this指针的是（）。

int fun1();
class Test{
public:
    int fun2();
    friend int fun3();
    static int fun4();
};

第94题

有如下程序，程序的输出结果是（）。

#include<iostream>
using namespace std;
class Obj{
    static int i;
public:
    Obj(){i++;}
    ~Obj(){i--;}
    static int getVal() {return i;}
};
int Obj::i=0;
void f(){Obj ob2;cout<<ob2.getVal();}
int main(){
    Obj ob1;
    f();
    Obj *ob3=new Obj;cout<<ob3->getVal();
    delete ob3;cout<<Obj::getVal();
    return 0;
}

第95题

有如下程序，程序的输出结果是（）。

#include<iostream>
using namespace std;
class MyClass{
public:
    MyClass(){++count;}
    ~MyClass(){--count;}
    static int getCount(){return count;}
private:
    static int count;
};
int MyClass::count=0;
int main(){
    MyClass obj;
    cout<<obj.getCount();
    MyClass*ptr=new MyClass;
    cout<<MyClass::getCount();
    delete ptr;
    cout<<MyClass::getCount();
    return 0;
}

第96题

 有如下定义，要初始化Point类的静态成员how_many，下划线处应填入的内容是（）。

class Point{
private:
    static int how_many;
};
______ how_many=0;

第97题

有如下类和对象的定义，下列各组语句中，能输出3.1416的是（）。

class Constants{ 
public: static double getPI(){return 3.1416;}
 }; 
Constants constants;

第98题

若AA为一个类，a为该类的非静态数据成员，在该类的一个成员函数定义中访问a时，其书写格式为（）。

第99题

有如下定义，上述程序段中，错误的语句是（）。

 cpp class Sample{ public: Sample(int x): ref(x) {}  //① private: Sample():ref(0) {}       //② static int val=5;        //③ const int ref;           //④ };

第100题

已知类Myclass的定义如下，其中有编译错误的函数是（）。

cpp class MyClass{ 
public: void function1(MyClass &c){cout<<c.data;} 
static void function2(MyClass &c){cout<<c.data;} 
void function3(){cout<<data;} 
static void function4(){
cout<<data;
} private: int data;
 };

第101题

有如下程序，若程序的输出结果是123，则程序中下划线处遗漏的语句是（）。

 #include<iostream> using namespace std; class Fun{ 
public: static int i; int value(){ return i-1;} int value()const{ return i+1;}
 };
 int Fun::i=2; int main(){ 
int i=3; Fun fun1; const Fun fun2; ________; return 0; }

第102题

有如下程序，运行时的输出结果是（）。

 #include<iostream> using namespace std; class VAC{ 
public: int f() const { return 3;}
 int f() {return 5;}
 }; 
int main(){ 
VAC v1; const VAC v2; 
cout<<v1.f()<<v2.f(); 
return 0; }

第103题

有如下程序，其主函数中错误的语句是（）。

 #include<iostream> using namespace std; class MyClass{ 
public: MyClass(int x):
val(x){} void SetInt x){val=x;} 
void Print()const{cout<<"val="<<val<<'\t';} 
private: int val; };
 int main(){ 
const MyClass obj1(10); MyClass obj2(20); obj1.Print();    //语句1 obj2.Print();    //语句2 obj1.Set(20);    //语句3 obj2.Set(20);    //语句4 return 0; }

第104题

有如下类定义和变量定义，下列函数调用中错误的是（）。

class A{
 public: A() {
 data=0;} ~A() {}
 int GetData() 
const { return data;}
 void SetData(int n) { data=n; 
} 
private: int data; };
 const A a; A b;

第105题

有如下程序，运行时的输出结果是（）。

 #include<iostream> using namespace std; 
class A { 
public: A(int i): r1(i) {} 
void print() {cout<<"E"<<r1*r1<<":";} 
void print() const {cout<<"C"<<r1*r1<<":";} 
private: int r1; }; i
nt main(){ A a1(2); 
const A a2(4); a1.print(); a2.print(); return 0; }

第106题

有如下程序，运行时的输出结果是（）。

#include<iostream> using namespace std; 
class A { public: A(int i=0):r1(i){} 
void print(){cout<<"E"<<r1*r1<<":";} 
void print() const {cout<<"C"<<r1*r1<<":";} 
void print(int x){cout<<"P"<<r1*r1*r1<<":";} 
private: int r1; }; 
nt main(){ A a1; const A a2(4); a1.print(2); a2.print(); return 0; }

第107题

某类中有一个无参且无返回值的常成员函数Show，则正确的Show函数原型是（）。

第108题

已知类IMS中两个成员函数的声明为 void listen（）const; 与 void speak（）; ，另有两个对象的定义为 IMS obj1; 与 const IMS obj2; ，则下列语句中，产生编译错误的是（）。

第109题

已知函数print（）没有返回值，如果在类中将其声明为常成员函数，正确的是（）。

第110题

有如下类定义，编译时没有错误的行是（）。

 class Test{ char a; const char b; public: Test(char c){a=c;b=c;}   
 //第1行 void f(char a)const{this->a=a;}//第2行 void g(char b){this->b=b;}     //第3行 char h() const{return a;}      //第4行 };

第111题

有如下定义，其中的四个函数定义中正确的是（）。

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<<a; } //④ };

第112题

有如下程序，运行时输出的结果是（）。

 #include<iostream> using namespace std; class Sample{ 
friend long fun(Sample s); 
public: Sample(long a):x(a){}
 private: long x; }; long fun(Sample s){ if(s.x<2) return 1
; return s.x*fun(Sample(s.x-1)); } 
int main(){ int sum=0; 
for(int i=0;i<6;i++)sum+=fun(Sample(i));
 cout<<sum; return 0; }

第113题

 有如下程序，下列叙述中正确的是（）。

 #include<iostream>
 #include<cmath> 
using std::cout; class Point{
 public: friend double distance(const Point &p); 
Point(int xx=0,int yy=0):x(xx),y(yy){} private: int x,y; }; 
double distance(const Point &p){ return sqrt(p.x*p.x+p.y*p.y); } 
int main(){ Point p1(3,4); cout<<distance(p1); return 0; }

第114题

有如下程序，下列关于程序的描述中，正确的是（）。

  #include<iostream> using namespace std; class Boat; class Car{ 
public: Car(int i):weight(i){} 
friend int Total(const Car &c,const Boat &b); 
private: int weight; }; class Boat{ public: Boat(int i):
weight(i){} friend int Total(const Car &c,const Boat &b); 
private: int weight; }; int Total(const Car &c,const Boat &b)
{ return c.weight+b.weight; } i
nt main(){ Car c(10); Boat b(8); cout<<"The total weight is "<<Total(c,b)<<endl; return 0; }

第115题

已知类MyClass声明如下，在下列数组定义中正确的是（）。

 class MyClass {
 public: MyClass(int d) { data = d;} ~MyClass() {} 
private: int data; };

第116题

已知类MyClass的定义如下，下列对MyClass类对象数组的定义和初始化语句中，正确的是（）。

  class MyClass {
 int n; 
public: MyClass(int k): n(k) {}
 int getValue()const { return n; } };

第117题

分析下面程序，该程序的运行结果是（）。

  #include<iostream> class TestClass{
public: static int m; TestClass() { m++; } TestClass(int n) { m=n; } 
static void test() { m++; } }; int TestClass::m=0; 
void main() { TestClass A; TestClass B(3); A.test(); 
TestClass::test(); cout<<"m="<<B.m<<endl; }

第118题

 下列说法中错误的是（）。

第119题

 有如下程序，执行后的输出结果是（）。

 #include<iostream> using namespace std; 
class TestClass{ public: ~TestClass (){cout<<"BASE:";} }; 
class TestClass1:
public TestClass { 
public: ~TestClass1 (){cout<<"DERIVED:";} }
; int main(){TestClass1 x;return 0;}

第120题

有以下定义和程序，以下不合语法的调用语句是（）。

 #include<iostream.h> class TestClass{ public: 
void show1() { cout<<"TestClass1"<<endl; } }; 
class TestClass2:TestClass1{
 public: void show2() {
 cout<<"TestClass2"<<endl; } }; 
class TestClass3:protected TestClass2{ 
public: void show3() { 
cout<<"TestClass3"<<endl; } }; 
void main() { TestClass1 obj1; TestClass2 obj2; TestClass3 obj3; }

第121题

在下面的4个关键字中用来说明虚函数的是（）。

第122题

有如下程序，执行后的输出结果是（）。

#include<iostream> using namespace std; class AA{ 
int n; 
public: AA(int k):n(k){} 
int get(){return n;} 
int get()const{return n+1;} }; i
nt main(){ AA a(5); const AA b(6); cout<<a.get()<<b.get(); return 0; }

第123题

关于函数重载，下列叙述中错误的是（）。

第124题

有如下类声明，下面关于setValue成员函数的实现中，正确的是（）。

class TestClass{ 
int n; 
public: TestClass (
int i=0):n(i){} 
void setValue (int n0); };

第125题

下面关于常成员函数的说法中正确的是（）。

第126题

下面关于虚函数的描述中，正确的是（）。

第127题

 在类中说明的成员可以使用关键字的是（）。

第128题

下列不能作为类的成员的是（）。

第129题

下列关于抽象类的表述中正确的是（）。

第130题

 假定TestClass为一个类，则该类的拷贝构造函数的声明语句为（）。