当前位置：首页 > news >正文

重写，重载，重定义习题

news 来源：原创 2024/5/6 9:05:51

1.关于重载、重写和重定义的区别说法正确的是（A,F ）

A.重写和重定义都发生在继承体系中

B.重载既可以在一个类中，也可以在继承体系中

C.它们都要求原型相同

D.重写就是重定义

E.重定义就是重写

F.重写比重定义条件更严格

G.以上说法全错误

A.重写即覆盖，针对多态，重定义即隐藏，两者都发生在继承体系中

B.重载只能在一个范围内，不能在不同的类里

C.只有重写要求原型相同

D.重写和重定义是两码事,重写即覆盖，针对多态，重定义即隐藏

E.重写和重定义是两码事,重写即覆盖，针对多态，重定义即隐藏

F.重写要求函数完全相同，重定义只需函数名相同即可

G.很明显有说法正确的答案

2.关于重载和多态正确的是（B ）

A.如果父类和子类都有相同的方法,参数个数不同, 姜子类对象服给父类对象后, 采用父类对象调用该同名方法时，实际调用的是子类的方法

B.选项全部都不正确

C.重载和多态在C++面向对象编程中经常用到的方法,都只在实现子类的方法时才会使用

D.class A{ public: void test(float a) { cout << a; } }; class B :public A{ public: void test(int b){ cout << b; } }; void main() { A *a = new A; B *b = new B; a = b; a->test(1.1); } 结果是1

A.使用父类对象调用的方法永远是父类的方法

B.正确

C.重载不涉及子类

D.输出结果为1.1

3.以下哪项说法时正确的（ D）

A.基类和子类的f1函数构成重写

B.基类和子类的f3函数没有构成重写，因为子类f3前没有增加virtual关键字

C.如果基类指针引用子类对象后，通过基类对象调用f2时，调用的是子类的f2

D.f2和f3都是重写，f1是重定义

class A
{
public:
  void f1(){cout<<"A::f1()"<<endl;}
  virtual void f2(){cout<<"A::f2()"<<endl;}
  virtual void f3(){cout<<"A::f3()"<<endl;}

};

class B : public A
{
public:
  virtual void f1(){cout<<"B::f1()"<<endl;}
  virtual void f2(){cout<<"B::f2()"<<endl;}
  void f3(){cout<<"B::f3()"<<endl;}
};

A.错误，构成重写是子类重写父类的virtual函数，

B.f3构成重写，重写时子类可以不要求加virtual关键字

C.通过父类对象调用的方法永远只能是父类方法

D.正确

4.关于虚表说法正确的是（ D）

A.一个类只能有一张虚表

B.基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表

C.虚表是在运行期间动态生成的

D.一个类的不同对象共享该类的虚表

A.多继承的时候，就会可能有多张虚表

B.父类对象的虚表与子类对象的虚表没有任何关系，这是两个不同的对象

C.虚表是在编译期间生成的

D.一个类的不同对象共享该类的虚表，可以自行写代码验证之

5.如果类B继承类A，A::x()被声明为虚函数，B::x()重写了A::x()方法，下述语句中哪个x()方法会被调用：( B)

B b;

b.x();

A.A::x()

B.B::x()

C.A::x() B::x()

D.B::x() A::x()

虽然子类重写了父类的虚函数，但只要是用对象去调用，则只能调用相对类型的方法，故B正确

6.以下程序输出结果是(C )

A.1 0

B.0 1

C.0 1 2

D.2 1 0

E.不可预期

F. 以上都不对

class A
{
public:
  A ():m_iVal(0){test();}
  virtual void func() { std::cout<<m_iVal<<‘ ’;}
  void test(){func();}
public:
  int m_iVal;
};

class B : public A
{
public:
  B(){test();}
  virtual void func()
  {
    ++m_iVal;
    std::cout<<m_iVal<<‘ ’;
  }
};

int main(int argc ,char* argv[])
{
  A*p = new B;
  p->test();
  return 0;
}

分析:new B时先调用父类A的构造函数，执行test()函数，在调用func()函数，由于此时还处于对象构造阶段，多态机制还没有生效，所以，此时执行的func函数为父类的func函数，打印0，构造完父类后执行子类构造函数，又调用test函数，然后又执行func(),由于父类已经构造完毕，虚表已经生成，func满足多态的条件，所以调用子类的func函数，对成员m_iVal加1，进行打印，所以打印1，最终通过父类指针p->test(),也是执行子类的func,所以会增加m_iVal的值，最终打印2，所以答案为C 0 1 2

7.下面函数输出结果是（ A）

A.B::f()

B.A::f()，因为子类的f()函数是私有的

C.A::f()，因为强制类型转化后，生成一个基类的临时对象，pa实际指向的是一个基类的临时对象

D.编译错误，私有的成员函数不能在类外调用

class A
{
public: 
  virtual void f()
  {
    cout<<"A::f()"<<endl;
  }
};

class B : public A
{
public:
   virtual void f()
  {
    cout<<"B::f()"<<endl;
  }
};

A* pa = (A*)new B;
pa->f();