C++ 多态（一）多态概念、实现与定义

什么是多态？讲一下多态理解，C++面试中80%概率会被问到的问题

1. 多态的概念

（概念+举例说明）

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态

举例：买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票

2. 多态的定义及实现

2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了

Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

2.3虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

练习：

需求：实现一个绘图软件// 如果是圆，画圆// 如果是矩形，画矩形// 如果是三角形，画三角形

代码如下：基本上包含了多态思想和效果

class Shape
{
public:
    // 虚函数
    virtual void Draw()
    {
        cout << "未知图形，暂时无法绘制" << endl;
    }

    virtual double GetPerimeter()
    {
        cout << "未知图形，无法获取周长" << endl;
        return 0;
    }
};

// 圆
class Cirle : public Shape
{
public:
    Cirle(double r)
        : _r(r)
    {}

    void Draw()
    {
        cout << "○" << endl;
    }

    virtual double GetPerimeter()//重写：把基类虚函数重新拷贝一份到子类，改变内部实现
    {
        return 2 * 3.14*_r;
    }
private:
    double _r;
};

// 矩形
class Rect : public Shape
{
public:
    Rect(double length, double width)
        : _length(length)
        , _width(width)
    {}

    void Draw()
    {
        cout << "□" << endl;
    }

    virtual double GetPerimeter()
    {
        return 2 * (_length + _width);
    }

private:
    double _length;
    double _width;
};

// 三角形
class Trangle : public Shape
{
public:
    Trangle(double a, double b, double c)
        : _a(a)
        , _b(b)
        , _c(c)
    {}

    virtual void Draw()
    {
        cout << "△" << endl;
    }

    // 在子类中重写基类中的虚函数方式：
    // 直接将基类中虚函数拷贝一份到子类中，然后将方法体中的代码重新实现，注意：方法的原型不能修改
    virtual double GetPerimeter()
    {
        return _a + _b + _c;
    }

private:
    double _a;
    double _b;
    double _c;
};


void DrawShape(Shape& s)
{
    s.Draw();
    cout << s.GetPerimeter() << endl;
}

int main()
{
    Cirle c(2);
    DrawShape(c);

    Rect rect(1, 2);
    DrawShape(rect);

    Trangle t(3, 4, 5);
    DrawShape(t);
    return 0;
}

虚函数重写的两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指

针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class A{};
class B : public A {};

class Person {
public:
     virtual A* f() {return new A;}
};

class Student : public Person {
public:
     virtual B* f() {return new B;}
};

2. 析构函数的重写(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，

都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，

看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处

理，编译后析构函数的名称统一处理成destructor

class Person {
public:
     virtual ~Person() {cout << "~Person()" << endl;}
};

class Student : public Person {
public:
     virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
     Person* p1 = new Person;
     Person* p2 = new Student;
     delete p1;
     delete p2;
     return 0;
}

面试题：一般情况下在继承体系中建议将基类的析构函数设置为虚函数---为什么

2.4 重载、覆盖(重写)、隐藏(重定义)的对比

重名隐藏与重写区别

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

    virtual void func1(int a)
    {
        cout << "B::func1(int)" << endl;
    }

    void func2()
    {
        cout << "B::func2()" << endl;
    }

    void func3()
    {
        cout << "B::func3()" << endl;
    }

    virtual void func4()
    {
        cout << "B::func4()" << endl;
    }
};

class D : public B
{
public:
    // 和基类中func1是重写的关系
    virtual void func1()
    {
        cout << "D::func1()" << endl;
    }
    // 和基类中func1是同名隐藏的关系，不是虚函数
    void func2()
    {
        cout << "D::func2()" << endl;
    }
    //和基类中func1是同名隐藏的关系，基类不是虚函数
    virtual void func3()
    {
        cout << "D::func3()" << endl;
    }
    //是虚函数，但是方法原型不一样
    virtual void func4(int a)
    {
        cout << "D::func4(int)" << endl;
    }
};
void TestVirtual(B& b)
{
    b.func1();
    b.func2();
    b.func3();
    b.func4();
}

int main()
{
    B b;
    TestVirtual(b);

    cout << "==================" << endl;
    D d;
    TestVirtual(d);
    return 0;
}

重写才会变D

2.5 C++11 override 和 fifinal

override ：只能修饰子类的虚函数，作用：让编译器在编译代码时，帮助检测是否重写了基类的某个虚函数， 如果重写了则编译通过，否则编译失败

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

    virtual void func2()
    {
        cout << "B::func2()" << endl;
    }

    virtual void funcI()
    {
        cout << "B::funcI()" << endl;
    }
};

class D : public B
{
public:
    virtual void func0()
    {
        cout << "D::func0()" << endl;
    }

    virtual void func2()override
    {
        cout << "D::func1()" << endl;
    }

    virtual void func1()override
    {
        cout << "D::func1()" << endl;
    }
};

fifinal修饰虚函数，表示该虚函数不能再被重写

1. 修饰类: 表明该类不能被继承

//设计一个类B，该类不能被其他类继承
class B final
{};

// 编译报错，因为B在定义时被final修饰了  因此B类是不能被继承的
 class D : public B
 {};

2. 修饰子类虚函数：修饰虚函数表明该虚函数不想被其子类重写

final实际也是只能修饰子类的虚函数

class B
{
public:
    // final修饰基类的虚函数实际是没有意义：
    // 在基类中，既然将func设置为虚函数，表明后序要在func上实现多态
    // 既然要在该方法上实现多态，则该方法必须要被子类重写

    // 但是该方法被final修饰了，表明该犯法不能被子类重写
    virtual void func()
    {
        cout << "B::func()" << endl;
    }
};

class D : public B
{
public:
    // func方法不想让后序子类再重写该方法了
    virtual void func()final
    {
        cout << "D::func()" << endl;
    }
};

class DD : public D
{
    // 子类不小心重写了则编译报错
    //     virtual void func()
    //     {
    //         cout << "D::func()" << endl;
    //     }
};