同一个消息被不同对象接收时，产生不同的结果。即采用不同方法实现同一接口。
联编
使一个源程序经过编译，连接，成为可执行文件的过程
静态联编
在程序运行之前就完成的联编
系统在编译时就知道调用函数的全部信息
函数调用速度快，效率高
动态联编
在程序运行时才能完成的联编
知道程序运行时才能确定调用哪个函数
灵活性，问题抽象性和程序易维护性
赋值兼容
在需要基类对象的任何地方，都可以使用共有派生类的对象来代替
Base b;Derived d; b=d;
Derived d; Base &br = d;
Derived d; Base *bptr = &d;
Derived *dptr; Base *bptr = dptr;
((Derived*)bpt)->print2(); //基类指针要强制转换才能访问派生类熟悉
虚函数
冠以关键字virtual的成员函数
如果在基类中定义了一个虚函数，该虚函数可以在它的一个或多个派生类中重载，不用冠以virtual也自动成为虚函数
运行时的多态（动态联编支持）
通过继承和虚函数来实现
->在基类，定义派生类所拥有的通用接口
->在派生类，定义具体的实现方法
->实现运行时的多态性
在程序中使用基类指针调用，知道程序运行时，系统才能确定调用哪一个函数
class base{
public;
virtual void show();
};
class de:public base
{
void show()
{
cout<<”de”<<endl;
}
};
eg:
class base{
protected:
double x,y;
public:
base(double a, double b)
{
x = a;
y = b;
}
~base();
virtual void show()
{
cout<<”base show”<<endl;
}
};
class de1:public base{
public:
de1(double a, double b):base(a,b)
{}
~de1();
void show()
{
cout<<”de1 show”<<endl;
}
};
class de2:public base{
public:
de2(double a, double b):base(a,b)
{}
~de2();
void show()
{
cout<<”de2 show”<<endl;
}
};
main()
{
base* pb;
de1 d1(22,22);
de2 d2(22,22);
pb = &d1;
pb->show();
pb = &d2;
pb->show();
return ();
}
纯虚函数（有一个或多个虚函数的类叫抽象类，抽象类不能实例化）
virtual type func_name(参数表)=0;
基类仅表示一种抽象的概念，并不与具体的事物相联系。
这样的虚函数在基类中没有定义
#include<iostream>
class shape(){
public:
virtual void draw()=0;
virtual void rotateshape()=0;
};
class circle():public shape{
int radius
public:
circle(int r)
{
radius = r;
}
void draw()
{
cout<<”draw”<<2*3.14*radius<<endl;
}
};
class rectangle():public shape{
protected:
double x,y;
public:
rectangle(double a, double b)
{x=a;y=b;}
void draw()
{
cout<<”draw”<<x*y<<endl;
}
};
float total(shape * arr[], int len)
{
double total = 0.0;
for (int i=0; i <n; i++)
{
total+=arr[i]->length();
}
return total;
}
main()
{
shape* arr[5];
circle c1(2,2);
arr[0] = &c1;
...
total(arr,5);
return 0;
}
编译时的多态（静态联编支持）
通过函数重载和运算符重载来实现
确定所调用函数的方式
参数匹配
支配原则
类名限定
运算符重载
运算符重载是通过创建运算符函数operator@()来实现的
运算符函数可以重载为：
类的成员函数
类的友员函数
eg
class A{
...
poublic:
A operator= (A &a);
friend A operator+ (A &a1, A &a2);
};
不允许重载的运算符：# . * ?:
自己不能创造运算符
成员运算符重载
函数的参数个数应比原有操作数个数少一个，还有一个是调用它的对象
class myclass{
public:
myclass operator+ (const myclass &a);
};
myclass myclass::operator+ (const myclass &a)
{
myclass temp;
temp.vaule1 = value1 + myclass.value1;
temp.vaule2 = value2 + myclass.value2;
return temp;
}
一元运算符重载
class myclass{
public:
myclass operator++();
myclass myclass::operator++()
{
++value1;
++value2;
return *this;
}
只能重载成成员函数不能重载为友员函数的运算符
= () [] ->
双目运算符一般重载为友员函数
单目运算符一般重载为成员函数
若运算符的操作需要修改类对象的状态选择成员运算符
若运算符的第一个操作数有隐式类型转换必须使用友员运算符