C++继承多态面试题总结

1.类的默认权限：private

2.类的编译顺序：类名---》编译成员名---》编译方法体
   类的构造顺序：成员对象---》类对象
   子类的构造：先构造父类，再构造子类
   子类的析构：先析构子类，再析构父类
   子类构造时需要提供父类的参数时，要在子类的初始化列表初始化

3. 成员方法之间的关系
重载：作用域相同    函数名相同     参数列表不同
隐藏：子类会隐藏父类中成员方法名相同的成员
覆盖：子类中的成员方法和父类中的一样的（同返回值，同参数列表，同名）虚成员方法，会发生覆盖

4.四种类型强转：
1）.const_cast:去掉const属性的类型强转
        const int a=1;int b=const_cast<int> (a);
2）.static_cast：编译器认为安全的
         int a;double b = static_cast<double>(a);
3）.dynamic_cast:运行时期类型强转，依靠RTT

条件：1.必须是指针
           2.继承关系的类型指针
           3.有RTTI
class A
{
   virtual void Fun()
 }
 class B:public A
 A *a = new B;
 B *b = a;
 b = dynamic_cast<B>(a); *a->class B typeid(*a)--><B>
 4)reinpreter_cast : 强制转换   (int)

5.虚表什么时候产生？存放在哪里？
 存放在.rodata
 编译期产生

6.多态：
静多态：重载   模板    编译时期的多态
动多态：继承中的多态  运行时期的多态  virtual

7.动多态发生的条件：
1).指针  引用调用  
2).virtual 该类型下的虚函数 
3).对象完整（构造之后，析构之前）
一定是指针的解引用  解引用访问的一定是虚函数 或者是 类型 

8.基类指针指向子类对象，指针是什么类型？*指针是什么类型？（基类中有虚函数）
   Base*  p = new Derive();
   typeid(p).name();  Base
   typeid(*p).name();  看RTTI，Derive

9.基类存在虚函数，子类覆盖，子类的内存布局
子类内存布局：
Base：：
vfptr
val
Derive::
val

10.基类无虚函数，子类有虚函数，子类的内存布局，基类指针指向堆上的子类对象，delete指针
崩溃，重载子类new基类delete打印指针值，指针指向子类对象基类开始部分
子类的内存布局：
vfptr（永远在前4个字节）
Base::
Derive::
基类指针指到的位置是vfptr的开头，而不是Base::段的开头，所以崩溃

11.基类定义虚函数和普通重载函数，子类定义同名函数隐藏普通函数和函数

class Base
{
public:
    void show();
    virtual void show(int);
};

class Derive : public Base
{
public:
    void show();
};

12.

基类指针指向堆上的子类对象，delete，子类析构函数未调用，调用基类析构函数

基类析构函数写成虚函数，delete，先调用子类析构函数，再调用基类析构函数
class Base
{
public:
    Base()
    {
        cout << "Base()" << endl;
    }

    virtual ~Base()
    {
        cout << "~Base()" << endl;
    }
};

class Derive : public Base
{
public:
    Derive()
    {
        cout << "Derive()" << endl;
    }
    ~Derive()
    {
        cout << "~Derive()" << endl;
    }
};

class Base
{
public:
    Base()
    {
        this->show(10);
    }
    virtual void show(int)
    {
        cout << "virtual void show(int)" << endl;
    }
};

class Derive : Base
{
public:
    Derive()
        :Base()
    {
        //this->show(10);
        this->Base::Base();
    }
    void show(int)
    {
        cout << "void show(int)" << endl;
    }
};

13.

基类虚函数放到共有，派生类虚函数放到私有，外部基类指针指向子类对象 能否派生类私有函数否访问
与类内的访问权限无关
可以访问
class Base
{
public:
    virtual void show(int)
    {
        cout << "Base :: virtual void show(int)" << endl;
    }
};

class Derive : public Base
{
public:

private:
    void show(int)
    {
        cout << "Derive :: void show(int)" << endl;
    }
};

int main()
{
    //Base* pb = new Derive();
    //delete pb;

    //Base b;
    //Derive d;

    Base* pb = new Derive();
    pb->show(10);

    return 0;
}

14.

基类和子类给不同的函数参数默认值，基类指针指向子类对象，调用函数
赋值在运行之前，并不知道是虚函数，只是把第一个遇见的值赋值
但是调用的还是子类的show方法

class Base
{
public:
    virtual void show(int a = 20)
    {
        cout << "a=" << a <<"==================" <<endl;
    }
};

class Derive : public Base
{
public:
    void show(int a = 30000)
    {
        cout << "a=" << a << endl;
    }
};

int main()
{
    Base*p = new Derive();
    p->show();

    return 0;
}

15.

基类构造清除所有数据，基类指针调用自己的虚函数，程序出错，已经清空
子类调用虚函数，打印出子类虚表中的内容
#include<iostream>
#include<string.h>
using namespace std;
#if 0
class Base
{
public:
    Base()
    {
        memset(this, 0, sizeof(Base));
    }

    virtual void show()
    {
        cout << "Base::virtual void show()" << endl;
    }
};
/*
vfptr 00000000
*/

class Derive : public Base
{
public:
    Derive()
        :Base()
    {
    }
    void show()
    {
        cout << "Derive::void show()" << endl;
    }
};

int main()
{
    //Base *pb = new Base();
    //pb->show();error

    Derive* pd = new Derive();
    pd->show();

    return 0;
}