（2）联编：在编译阶段进行联接。即是在编译阶段将一个函数的调用点和函数的定义点联接起来。
A.静态联编：在编译阶段就完毕的函数联编——函数重载。

B.动态联编：在程序的执行阶段由系统自己主动选择详细的函数——虚函数。

注：C++的多态主要指的就是动态联编。
2.虚函数
（1）虚函数是在函数的定义时将其声明为虚函数就可以。
（2）说明：virtual 数据类型 函数名（參数表） {函数体}
A.目的：当通过基类指针调用虚函数时，系统进行动态联编。
B.在派生类中定义了和基类名称同样、參数个数同样、參数类型同样、返回值类型同样的函数时。若基类中的同名成员函数是虚函数，派生类的同名成员函数将自己主动被虚化。

C.通过对象訪问虚函数时採用静态联编。

动态联编仅仅可以通过指向对象的指针和对象的引用来完毕。
3.样例
example 1

#include <iostream.h>

class Point(
{
private:
    float x, y;
public:
    void setpoint(float i, float j)
    {
        x = i; y = j;
    }
    float area() {return 0.0;}//等价于：float area()=0;
};
const float PI=3.1416;
class Circle:pulic Point
{
private:
    float rad;
public:
    void setrad(float r) {rad = r;}
    float area() {return PI*rad*rad;}
};
int main()
{
    Point p;
    Circle c;
    float a = p.area();
    cout<<a<<endl;
    c.setrad(2.5);
    a = c.area();
    cout<<a<<endl;
}
分析：
float a=p.area()调用的是Point类的area函数：p是基类Point的对象；对象调用函数时採用静态联编；Point类的对象调用area，area一定是Point类的area；a=c.area()调用的是Circle类的area函数，由于就近原则。

改动main函数：

int main()
{
    Point *p;
    Circle c;
    float a;
    c.setrad(2.5);
    p = &c;
    a = p->area();//该函数属于静态联编
    cout<<a<<endl;
}
程序输出：
0.0
分析：虽然基类指针指向了派生类对象，但仅仅可以通过基类的指针引用派生类对象从基类继承过去的成员。假设要想基类指针可以指向派生类的成员，那么就要使用虚函数，从而实现动态联编。

4.四种静态联编
（1）基类指针指向基类对象，採用静态联编调用基类成员。
（2）派生类的指针指向派生类的对象採用静态联编，调用派生类成员。若派生类没有的成员。调用基类的该成员。

（3）基类指针指向派生类对象，採用静态联编，调用基类成员。

（4）对象引用成员一定是静态联编。基类对象引用基类成员，派生类对象引用派生类成员，若派生类没有则能够引用基类成员。
注：派生类指针不可指向基类，引用也不能够。
5.动态联编
（1）条件：基类的同名函数被声明为虚函数。基类指针指向派生类对象。

（2）作用：使用动态联编。使得一个基类指针能够訪问多个派生类的成员函数，动态联编仅仅能通过指针或引用来实现（前提是虚函数机制）。
example 2

#include <iostream.h>

class Point
{
public:
    virtual double area() {return 0.0;}
};
class Rectangle:public Point
{
    double length, width;
public:
    Rectangle(double l, double w):length(l), width(w) {}
    double area() {return length*width;}
};
class Circle:public Point
{
    double radium;
public:
    Circle(double r) {radium = r;}
    double area() {return 3.1416*radium*radium;}
};
class Triangle:public Point
{
    double x, y, z;
public:
    Triangle(double a, double b, double c)
    {x = a; y = b; z = c;}
    double area() {return (x+y+z)*0.5;}
};
int main()
{
    Point *p;
    Rectangle r(5.0, 2.0);
    Circle c(6.0);
    Triangle t(3.0, 4.0, 5.0);
    p = &r;
    cout<<p->area()<<endl;
    p = &c;
    cout<<p->area()<<endl;
    p = &t;
    cout<<p->area()<<endl;
}
程序输出：
10
113.098
6
注：基类的虚函数也能够被调用。调用方法：加类的作用域（强制採用静态联编）。
演示样例：
p = &r;
p->area();//调用Rectangle类的area函数
p->Point::area();//强制採用静态联编，调用Point类作用下的area函数
6.虚函数的訪问权限
（1）派生类中的虚函数不影响动态联编，基类的虚函数是保证动态联编的必要条件。
（2）一个类中的虚函数仅仅对派生类重定义的函数有影响，对它的基类成员无影响。

example 3

#include <iostream.h>

class A
{
public:
    virtual void fun1()
    {cout<<"fun1()...fun2()"<<endl; fun2();}
    void fun2()
    {cout<<"fun2()...fun3()"<<endl; fun3();}
    virtual void fun3()
    {cout<<"fun3()...fun4()"<<endl; fun4();}
    virtual void fun4()
    {cout<<"fun4()...fun5()"<<endl; fun5();}
    void fun5() {cout<<"The end."<<endl;}
};
class B:public A
{
    void fun3()
    {cout<<"fun3...fun4"<<endl; fun4();}
    void fun4()
    {cout<<"fun4...fun5"<<endl; fun5();}
    void fun5()
    {cout<<"All done."<<endl;}
};
int main()
{
    A *thing;
    thing = new A;
    thing->fun1();
    thing = new B;
    thing->fun1();
}
程序输出：
fun1()...fun2()
fun2()...fun3()
fun3()...fun4()
fun4()...fun5()
The end.
fun1()...fun2()
fun2()...fun3()
fun3...fun4
fun4...fun5
All done.
7.若基类和派生类中的同名函数參数个数不同。參数类型不同，基类中的成员函数虽然是虚函数。但将丢失虚特性——採用静态联编。
基类和派生类中的同名成员函数，若出现基类中的同名成员函数非虚，派生类中同名成员函数是虚函数。那么也将採用静态联编。
example 4

#include <iostream.h>

class Base
{
public:
    virtual void fun1() {cout<<"Base fun1."<<endl;}
    virtual void fun2() {cout<<"Base fun2."<<endl;}
    void fun3() {cout<<"Base fun3."<<endl;}
    void fun4() {cout<<"Base fun4."<<endl;}
};
class Device:public Base
{
public:
    virtual void fun1()
    {cout<<"Device fun1."<<endl;}
    virtual void fun2()
    {cout<<"Device fun2."<<endl;}
    virtual void fun3()
    {cout<<"Device fun3."<<endl;}
    virtual void fun4()
    {cout<<"Device fun4."<<endl;}
};
int main()
{
    Base *pb;
    Device d;
    pb = &d;
    pb->fun1();
    pb->fun2();
    pb->fun3();
    pb->fun4();
}
程序输出：
Device fun1.
Device fun2.
Base fun3.
Base fun4.