c++多态特性看懂这一篇就够了

什么是多态？有哪些分类？

答：多态是面向对象的重要特性之一，它是一种行为的封装，是同一种事物所表现出的多种形态，简单地说是”一个接口多种实现“

有两种类型的多态性：

编译时的多态性。编译时的多态性是通过重载来实现的。

运行时的多态性。运行时的多态性是通过虚成员实现的。

构造函数为什么不能是虚函数？
1.从存储空间角度。 虚函数对应一个vtable，这个vtable其实是存储在对象的内存空间的。问题出来了，如果构造函数是虚的，就需要通过 vtable来调用，可是对象还没有实例化，也就是内存空间还没有，无法找到vtable，所以构造函数不能是虚函数。
2，从使用角度 构造函数本身就是要初始化实例，那使用虚函数也没有实际意义呀。所以构造函数没有必要是虚函数。虚函数的作用在于通过父类的指针或者引用来调用它的时候能够变成调用子类的那个成员函数。而构造函数是在创建对象时自动调用的，不可能通过父类的指针或者引用去调用，因此也就规定构造函数不能是虚函数。
3、构造函数不需要是虚函数，也不允许是虚函数，因为创建一个对象时我们总是要明确指定对象的类型，尽管我们可能通过实验室的基类的指针或引用去访问它。
**4、从实现上看，**vbtl在构造函数调用后才建立，因而构造函数不可能成为虚函数

析构函数为什么应该设置成虚函数？
答：假设没有设置成虚函数，如果有基类指针指向派生类，那么用基类指针delete时，如果不定义成虚函数，派生类中派生的那部分无法析构，造成内存泄漏。

类成员函数中重载/重写(覆盖)/重定义(隐藏)的区别？
答：分别简单讲述一下函数重载，函数覆盖，函数隐藏的概念与特征：
函数重载：重载函数通常用来命名一组功能相似的函数
1.函数要在相同的类域
2.函数的名字要相同
3.函数的参数列表或返回值不同

函数覆盖：覆盖是指派生类函数覆盖基类函数
1.函数是要在不同的类域
2.两个函数的名称相同
3.基类函数必须是虚函数
4.两个函数的参数相同

函数隐藏：指派生类的函数屏蔽了与其同名的基类函数
1.两个函数在不同的类域
2.函数名称相同
3.函数参数不同
4.如果派生类函数与基类函数参数相同，但是在基类函数中没有virtual关键字，发生函数隐藏

友元可以继承吗？
不能！友元只是能访问指定类的私有和保护成员的自定义函数，不是被指定类的成员，自然不能继承。 使用友元类时注意：
(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3)友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

静态成员及静态成员函数能不能被继承？
基类与派生类的静态成员函数与静态成员是共用一段空间的，即静态成员和静态成员函数是可以继承的。
所以，我们可以得出以下结论：

父类的static变量和函数在派生类中依然可用，但是受访问性控制（比如，父类的private域中的就不可访问）。而且对static变量来说，派生类和父类中的static变量是共用空间的，这点在利用static变量进行引用计数的时候要特别注意。
构造函数析构函数调用顺序
1.基类对象首先被创建
2.派生类构造函数应通过成员初始化列表（调用顺序和继承顺序相关）将基类信息传递给基类构造函数 ，可以使用初始化列表句法指明要使用的基类构造函数，否则将使用默认的基类构造函数。
3.派生类构造函数应初始化派生类新增的数据成员
派生类对象析构时，程序首先调用派生类析构函数，再调用基类析构函数。

 

 

来一个多态的综合例子：

#include <iostream>
using namespace std;

class A
{
public:
        virtual void ff()
        {
                cout<<"A::ff()"<<endl;
        }
        void gg()
        {
                cout<<"A::gg()"<<endl;
        }
        void hh(int x)
        {
                cout<<"A::hh()"<<endl;
        }
};

class B :public A
{
public:
        virtual void ff()
        {
                cout<<"B::ff()"<<endl;
        }
        void gg()
        {
                cout<<"B::gg()"<<endl;
        }
        void hh(float x)
        {
                cout<<"B::hh()"<<endl;
        }
};

int main()
{
        B b;
        A* pa = &b;
        B* pb = &b;
        pa->ff(); //多态，即就是重写或者叫覆盖
        pb->ff();
        cout<<"--------------------"<<endl;

        pa->gg();
        pb->gg();
        cout<<"------------\n";
        pa->hh(3); 
        pb->A::hh(3);
        cout<<"------------\n";
        A a;
        B *pb_ = (B*)&a;
        pb_->ff();
        pb_->gg();
        return 0;
}

 

运行的结果：

 

 

 

如果看不明白结果可以看一下这个博客

https://blog.csdn.net/ypt523/article/details/79598289