C++测试题

 

1、  下面关于类概念的描述中，___D_是错误的。

A．类是抽象数据类型的实现

B．类是具有共同行为的若干对象的统一描述体

C．类是创建对象的样板

D．类是C语言中的结构体类型

 

2、下列对重载函数的描述中，__A__是错误的。

A．重载函数中不允许使用默认参数

B．重载函数中编译是根据参数表进行选择//与返回值无关，只和函数入口有关

C．不要使用重载函数来描述毫无相干的函数

D．构造函数重载将会给初始化带来多种方式

 

3、有以下类的说明，请指出错误的地方。

Class sample

{

int a=2.5;//改为int a;

sample();

public:

 sample(int val);

~sample();

};

 

4、有关析构函数的说法不正确的是_C___。

A、析构函数有且只有一个

B、析构函数无任何函数类型

C、析构函数和构造函数一样可以有形参

D、析构函数的作用是在对象被撤消时收回先前分配的内存空间

 

 

5、下列说法中正确的是___B_。

A.类定义中只能说明函数成员的函数头，不能定义函数体

B.类中的函数成员可以在类体中定义，也可以在类体之外定义

C.类中的函数成员在类体之外定义时必须要与类声明在同一文件中

D.在类体之外定义的函数成员不能操作该类的私有数据成员

   

 

6、下列定义中，sample是一个类，___B_是定义指向对象数组的指针P。

A. sample *p[5]

B. sample (*p)[5]

C. (sample *p)p[5]

D. sample *p[]

 

7、下列程序的执行结果是

Class sample

{

Public:

   Sample(){cout<<”constructor”<<endl;}

};

Void fn(int i)

{

       Staticsample c;

Cout<<”i=”<<i<<endl;

}

Void main()

{

       fn(10);

   fn(20);

}

--------

constructor

i=10

i=20

 

8、改正下列程序中的错误

Class point

{

   intx,y;

   public:

   point(intx,int y);

};

Void main()

{

   Pointdata(5,5);

   Cout<<data.x<<endl;

   Cout<<data.y<<endl;

}

------

class point

{

   public:

   point(int a,int b){x=a;y=b;}

   int x,y;

};

int main()

{

   point data(5,5);

   cout<<data.x<<endl;

   cout<<data.y<<endl;

   return 0;

}

9、找出程序中的错误，并说明原因

Class sample

{

       Public:

Static voidf(sample my);

Private: int n;

};

Void sample::f()

{

       Cout<<n<<endl;

}

-------------

静态成员函数不可以访问非静态成员。

10、阅读以下程序，找出错误的地方，并说明原因。

Class sample

{

       intx,y,c;

public:

       sample(inti=0,int j=0);

void f() const;

};

Voidsample::f() const

{

       Cout<<x<<””<<y<<endl;

c++;

}

-------

Const函数不可以改变变量的值

 

11、若有：

int i;

int &j=i;

i=5;

j=i+1;

则i=___6_, j=__6__.

 

12、阅读以下程序，如果程序中有错误，找出错误，说明原因并改正，如没有错误，请写出运行结果。

#include <iostream.h>

int &add(int x,int y)

{

       returnx+y;

}

Void main()

{

       intn=2,m=10;

       cout<<(add(n,m)+=10)<<endl;

}

-------------

Return x+y 不是一个确切的变量，所以不能当做引用返回。

13、下面关于友元的描述中，错误的是（D）

A．友元函数可以访问该类的私有数据成员

B．一个类的友元类中的成员函数都是这个类的友元函数

C．友元可以提高程序的运行效率

D．类与类之间的友元关系可以继承

 

14、下列关于class 与struct差别说法中，正确的是（A）

A、class 成员缺省为私有的，而struct成员缺省为公有的；

B、class 成员缺省为公有的，而struct成员缺省为私有的；

C、class不能在内部定义函数，而struct可以在内部定义函数；

D、class 可以在内部定义函数，而struct不能在内部定义函数；

 

 

15、友元运算符obj1>obj2被C++编译器解释为__C__。

A. obj2. operator>(obj1)

B. obj1. operator>(obj2)

C．operator>(obj1,obj2)

D. >(obj1,obj2)

 

 

17、为了满足运算符“+”的可交换性，必须将其重载为__友元函数__。

//虽然将运算符重载为成员函数答案一样，但是函数在调用过程中所走的程序不同，而重载为友元函数只是参数的位置不同，并没有影响函数内部的走法。

18、#include”iostream.h”

main()

{

int a[3][3]={1,3,6,2,4,8,5,7,9};

cout<<*(a[1]+1);

}

则输出结果为：       4      

 

 

19、函数重载、覆盖、隐藏的区别？

下面我们从成员函数的角度来讲述重载和覆盖的区别：

重载的特征有：（“重复”、“重叠”）―――――――――――――――――（静态联编）

1) 相同的范围（在同一个类中）；

2) 函数名字相同；

3) 参数不同；

4) 返回值可相同、可不同；

5) virtual关键字可有可无。

覆盖的特征有：（“使原来的失去效果”）―――――――――――――――（动态联编）

1) 不同的范围（分别位于派生类与基类）；

2) 函数名字相同、参数列相同、返回值类型相同；

3) 只有函数体（花括号中的部分）不同；

4) 基类函数必须有virtual关键字。

//覆盖在用派生类地址赋值给基类指针时用得着，因为基类指针对自己所调用的函数有要求，所以要想展示动态联编的效果，那么派生类成员函数必须和基类成员函数一模一样，不然指针不会调用派生类函数（找不到可以覆盖原函数的函数）。

隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：―――――（静态联编）

1)  如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意，不要与重载混淆）。

2)  如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意，不要与覆盖混淆）。

隐藏与覆盖到底有什么区别？

    在覆盖中，用基类指针和派生类指针调用函数f()时，系统都是执行的派生类函数f()，而非基类的f()，这样实际上就是完成的“接口”功能。

而在隐藏中，用基类指针和派生类指针调用函数f()时，系统会进行区分，基类指针调用时，系统执行基类的f()，而派生类指针调用时，系统“隐藏”了基类的f()，执行派生类的f()，这也就是“隐藏”的内在特点。

20、虚函数是动态联编的基础，虚函数一定是非static的成员函数。

当类中的一个成员函数被说明为虚函数，这就意味着该成员函数在派生类中可能有不同的定义。当使用这个成员函数操作指针或引用所标识的对象时，将对该成员函数调用采取动态联编方式；

动态联编只能通过指针或引用标识对象来操作虚函数，或者由成员函数调用虚函数。如果采用一般类型的标识对象来操作虚函数，则将采用静态联编方式调用虚函数。

下面看一个例子：

#include <iostream.h>

class point

{

        int x,y;

public:

        point(int x1,int y1){x=x1;y=y1;}

        virtual int area() const {return 2;}

};

class rect:public point

{

        int l,w;

public:

        rect(int x1,int y1,int l1,int w1):point(x1,y1)

        {

                       l=l1;w=w1;

        }

        virtual int area() const {return l*w;}

};

void fun(point &p)

{

        cout<<p.area()<<endl;

}

void main()

{

        rect rec(2,4,10,6);

        fun(rec);

}

输出结果应为多少？若将（point &p）改为（point p），结果如何？ 

60  2

21、关于动态联编的下列描述中，__D___是错误的。

A、动态联编是以虚函数为基础的

B、动态联编是在运行时确定所调用的函数代码

C、动态联编调用函数操作是指向对象的指针或对象引用

D、动态联编是在编译时确定操作函数的

22、对虚函数的调用___D__。

A、一定使用动态联编

B、必须使用动态联编

C、一定使用静态联编

D、不一定使用动态联编

//如果是对象调用虚函数，那么只会执行该对象所对应的函数，这个是确定的，所以此时是静态联编

23、关于纯虚函数和抽象类的描述中，___C__是错误的。

A、纯虚函数是一种特殊的虚函数，它没有具体的定义

B、抽象类指具有纯虚函数的类

C、一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类

D、抽象类只能作为基类来使用，其纯虚函数的定义由派生来给出

24、阅读程序，讨论程序的输出结果。

#include <iostream.h>

class A

{

public:

        virtual ~A(){cout<<"call A::~A()"<<endl;}

};

class B:public A

{

        char *buf;

public:

        B(int i){buf=new char[i];}

        virtual ~B()

        {

                       delete []buf;

                       cout<<"call B::~B()"<<endl;

        }

};

void fun(A *a)

{

        delete a;

}

void main()

{

        A *a=new B(10);

        fun(a);

}

call B::~B()

call A::~A()

25、编程题：

（1）定义一个复数类，实部用real变量，虚部用image变量，且均为double型，要求：

①当创建对象时不传参数，则real，image均为0；当传入一个实部参数时，则real=传入参数，image=0; 

②定义一个“*”（乘号）运算符重载，重载为成员函数，实现复数的乘法运算。

（2）定义一个抽象类Shape,其中有纯虚函数double area()；由Shape再派生出Circle、Rectangle类， Circle类中有中

心点坐标为int x,y半径为double R，面积为double area() ；Rectangle类有长（long）与宽（wide）, 面积为double 

area() ,设计一个函数dispalyArea()，其功能为显示面积，其形参为Shape类指针，请编程实现动态联编计算面积

的多态性。

（1）

class FS{

       double real, image;

public:

       FS(double a=0,double b=0){real =a; image =b;}

       FS operator *(FS f)

       {

              FS g=*this;

              g.real= g.real*f.real- g.image*f.image;

              g.image= g.real* f.image+ g.image* f.real;

              return g;

       }    

};

 

 

（2）

#include "iostream.h"

 

class Shape

{

public:

       virtual double area()=0;

}; 

 

class Circle:public Shape

{

private:

       int x,y;

       double R;

public:

    Circle(double r){R=r;}

       double area()

       {

              return 3.1415*R*R;

       }

}; 

 

class Rectangle:public Shape

{

private:

       double Long,Wide;

public:

       Rectangle(double x,doubley){Long=x;Wide=y;}

       double area()

       {

              return Long*Wide;

       }    

}; 

void dispalyArea(Shape *S)

{

       cout<<S->area()<<endl;

} 

void main()

{

       Circle C(2);

       Rectangle R(3,4);

       dispalyArea(&C);

       dispalyArea(&R);

}

总结:

可以访问类中的私有数据成员的是：

1、类体的成员函数

2、类体的成员函数中的形参中的该类的对象、对象引用或者对象指针，以及函数体中定义的局部对象、对象引用或者对象指针。(1，2说明只要是在类的内部就可以，除了static，那是类级的概念)

3、类的友元函数中的形参中的该类的对象、对象引用或者对象指针，以及函数体中定义的局部对象、对象引用或者对象指针。（也就是在友元函数体内）

4、类的友元类的成员函数中形参中的该类的对象、对象引用或者对象指针，以及函数体中定义的局部对象、对象引用或者对象指针。（同样就是在友元函数体内，友元类的成员函数就是该类的友元函数）