多态性

一、多态性

1、多态考虑在不同层次的类中，以及一个类的内部，同名成员函数之间的关系问题，解决功能和行为的在抽象问题。直观来讲，多态是指类族中具有相似功能的不同函数使用同一个名称来实现，从而可以使用相同的调用方式来调用这些具有不同功能的函数。

 

2、多态性可以分为：重载多态；强制多态；包含多态；参数多态。

   包含多态是研究类族中定义于不同类中的同名成员函数的多态行为，主要是通过虚函数来实现。

   参数多态与类模板相关联。

 

3、多态的实现：编译时的多态和运行时的多态。

 

二、运算符重载

1、运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。实质是函数重载。

 

2、运算符重载规则:

   只能重载已存在的运算符（还有"."，“*”，“：：”，“sizeof”， “？ ：”不能被重载）；

   重载后优先级和结合性不能改变。

 

3、运算符可以重载为类的成员函数或重载为友元函数。语法分别为：

   函数类型 operator 运算符（形参表）

   {

       函数体；

   }

或 friend 函数类型 operator 运算符（形参表）

   {

       函数体；

   }

例子：复数类加减法——双目运算符重载为成员函数

#include <iostream>
#include <time.h>
using namespace std;

class complex
{
public:
    complex(double r = 0.0, double i = 0.0)
    {
        real = r;
        imag = i;
    }
    complex operator +(complex c2);
    complex operator -(complex c2);
    void display();
private:
    double real; //实部
    double imag; //虚部
};

complex complex::operator +(complex c2)
{
    return complex(real+c2.real, imag + c2.imag);    //创建无名对象返回
}

complex complex::operator -(complex c2)
{
    return complex(real-c2.real, imag - c2.imag);   //创建无名对象返回
}

void complex::display()
{
    cout<<"("<<real<<","<<imag<<")"<<endl;
}

int main()
{
    complex c1(5,4), c2(2,10), c3;
    cout<<"c1 = ";
    c1.display();
    cout<<"c2 = ";
    c2.display();
    c3 = c1 - c2;
    cout<<"c3 = c1 - c2 = ";
    c3.display();
    c3 = c1 + c2;
    cout<<"c3 = c1 + c2 = ";
    c3.display();

    return 0;
}

例子：单目运算符重载为成员函数

将单目运算符重载为成员函数，则需要使用参数，但是对于单目运算符++,--，对于前置单目运算法，函数重载没有形参，后置单目运算符，重载函数有一个整形形参。

例子：复数类加减法——运算符重载为友元函数

#include <iostream>
#include <time.h>
using namespace std;

class complex;
complex operator +(complex c1, complex c2);
complex operator -(complex c1, complex c2);

class complex
{
public:
    complex(double r = 0.0, double i = 0.0)
    {
        real = r;
        imag = i;
    }
    friend complex operator +(complex c1, complex c2); //友元函数
    friend complex operator -(complex c1, complex c2); //友元函数
    void display();
private:
    double real; //实部
    double imag; //虚部
};

 complex operator +(complex c1, complex c2)
{
    return complex(c1.real+c2.real, c1.imag + c2.imag);
}

complex operator -(complex c1, complex c2)
{
    return complex(c1.real-c2.real, c1.imag - c2.imag);
}

void complex::display()
{
    cout<<"("<<real<<","<<imag<<")"<<endl;
}

int main()
{
    complex c1(5,4), c2(2,10), c3;
    cout<<"c1 = ";
    c1.display();
    cout<<"c2 = ";
    c2.display();
    c3 = c1 - c2;
    cout<<"c3 = c1 - c2 = ";
    c3.display();
    c3 = c1 + c2;
    cout<<"c3 = c1 + c2 = ";
    c3.display();

    return 0;
}

三、虚函数

1、虚函数是动态联编的，虚函数是非静态的成员函数，虚函数经过派生之后，在类族中就可以实现运行过程中的多态。

2、如果需要通过基类的指针指向派生类的对象，并访问某个与基类同名的成员（如果是函数，其原型完全相同），那么首先在基类中将这个同名函数说明为虚函数。通过基类类型的指针，就可以使属于不同派生类的不同对象产生不同的行为，从而实现运行时的多态，

3、语法：

virtual 函数类型 函数名（形参表）

{

    函数体；

}

虚函数必须在声明时出现virtual，在定义时指定不是现实虚函数。

4、运行多态需要满足的条件：类之间应满足赋值兼容规则；声明虚函数；要由成员函数来调用或者是通过指针、引用来访问虚函数。如果使用对象来访问虚函数，则联编在编译过程中就可以进行（静态联编），而无需在运行过程中进行。

5、例子

#include <iostream>
#include <time.h>
using namespace std;

class B0
{
public:
    virtual void display()
    {
        cout<<"B0::display()"<<endl;
    }
};

class B1:public B0
{
public:
    void display()
    {
        cout<<"B1::display()"<<endl;
    }
};

class B2:public B0
{
public:
    void display()
    {
        cout<<"B2::display()"<<endl;
    }
};

void fun(B0 *ptr)
{
    ptr->display();
}

int main()
{
    B0 b0, *p;
    B1 b1;
    B2 b2;
    fun(&b0);
    p = &b1;
    fun(p);
    p = &b2;
    fun(p);

    return 0;
}

输出结果：

B0::display()

B1::display()

B2::display()

6、虚析构函数：C++中不能声明虚构造函数，但能声明虚析构函数。

四、抽象类

1、抽象类是一种特殊的类，它为一族类提供统一的操作界面。建立抽象类，就是为了通过它多态地使用其中的成员函数。一个抽象类自身无法实例化，即无法声明一个抽象类的对象，但可以声明一个抽象类的指针和引用。抽象类是带有纯虚函数的类。

2、纯虚函数

   纯虚函数是一个基类中说明的虚函数，它在该基类中没有定义具体的操作内容，要求各派生类根据实际需要定义自己的版本。语法为：

virtual 函数类型 函数名（参数表）= 0；