C++中的多态

多态性是面向对象程序设计的重要特征之一。多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。

多态的实现方式包括以下3种：函数重载、运算符重载、虚函数。

1、运算符重载：

#include<iostream>
using namespace std;

class Complex
{
private:
    int real,imag;
public:
    void show() const;
    Complex operator +(const Complex c);
    Complex operator -(const Complex c);
    /*
    Complex(int a=0,int b=0)
    {
        real=a;imag=b;
    }
    */
    Complex(int a=0,int b=0):real(a),imag(b)
    {}
};//don't forget this!

void Complex::show() const
{
    cout<<"real:"<<real<<"imag:"<<imag<<endl;
}

Complex Complex::operator +(const Complex c)
{
    Complex ret;
    ret.real=real+c.real;
    ret.imag=imag+c.imag;
    return ret;
}

Complex Complex::operator -(const Complex c)
{
    Complex ret;
    ret.real=real-c.real;
    ret.imag=imag-c.imag;
    return ret;
}

int main()
{
    Complex a(2,3),b(-1,5),c,d;
    a.show();
    b.show();
    c=a+b;
    d=a-b;
    c.show();
    d.show();
    return 0;
}

注意运算符重载操作数个数：重载为类的成员函数时，参数个数=原操作数个数-1（后置++、--除外）；重载为非成员函数时，参数个数=原操作数个数，且至少有一个自定义类型。

#include<iostream>
using namespace std;

class Clock
{
private:
    int hour,minute,second;
public:
    Clock(int a=0,int b=0,int c=0):hour(a),minute(b),second(c)
    {
        //hour=a;minute=b;second=c;
    }
    void show() const;
    Clock operator ++();
    Clock operator ++(int);
};

void Clock::show() const
{
    cout<<hour<<":"<<minute<<":"<<second<<endl;
}

//before
Clock Clock::operator ++()
{
    if(second+1>=60)
    {
        second=second-60;
        if(minute+1>=60)
        {
            minute=0;
            if(hour+1>=24)
                hour=0;
            else hour=hour+1;
        }
        else minute=minute+1;
    }
    else second=second+1;
    return *this;
}

//behind   still one argument
Clock Clock::operator ++(int)
{
    Clock ret=*this;
    ++(*this);
    return ret;
}

int main()
{
    Clock clock(23,59,59);
    cout<<"The time is:";
    clock.show();

    cout<<"(Time++) is:";
    (clock++).show();

    cout<<"(++Time) is:";
    (++clock).show();
    return 0;
}

前置++重载，0个操作数；后置++重载，1个操作数，函数中不需要使用该操作数。

 

2、虚函数：

注意事项：若需要使用多态，则继承方式必须是public或者protected继承，且需要使用到的虚函数在基类中必须是public类型。

#include<iostream>
using namespace std;

class Base1
{
public:
    virtual void show()
    {
        cout<<"I am base1!"<<endl;
    }
};

class Base2
{
public:
    void show()
    {
        cout<<"I am base2!"<<endl;
    }
};

class Derived1:public Base1
{
    void show()
    {
        cout<<"I am Derived1!"<<endl;
    }
};

class Derived2:public Base2
{
    void show()
    {
        cout<<"I am Derived2!"<<endl;
    }
};

class Derived3:public Base1,public Base2
{
    void show()
    {
        cout<<"I am Derived3!"<<endl;
    }
};

int main()
{
    Base1 *p1;
    Base2 *p2;
    Derived1 d1;
    Derived2 d2;
    Derived3 d3;

    p1=&d1;
    p1->show();

    p2=&d2;
    p2->show();

    p1=&d3;
    p1->show();
    p2=&d3;
    p2->show();

    return 0;
}

纯虚函数：virtual void func()=0;

抽象类：包含了纯虚函数的类。