#include <iostream>

using namespace std;
#define Huilv 0.9
class Manager
{
private:
    int x,y;

public:
    Manager(int x=0,int y=0)
    {
        this->x = x;
        this->y = y;
    }
    double Money()
    {
        return x*y;
    }
};
class Employee:public Manager
{
private:
    int r;
public:
    Employee(int x,int y,int z):Manager(x,y)
    {
        r = z;
    }
    double Money()
    {
        return Huilv*r;
    }
};

int main()
{

    Manager A(10,10);
    cout<<A.Money()<<endl;
    Employee B(10,10,20);
    cout<<B.Money()<<endl;
    Employee *p;//注意指针的类型
    p = &B;
    cout<<p->Money()<<endl;
    Manager &pp=B;//注意引用的类型
    cout<<pp.Money()<<endl;
    return 0;

}

3 结果与说明

我们可以看到,最后一个输出是出乎我们逻辑上的预料的,其实这正是静态联编的结果,该非虚函数在编译时就已经根据其引用的类型决定了将使用基类中的相应函数,输出结果,而没有根据其地址指向的类型决定调用哪个函数,这时便需要我们在执行时再决定调用.

不过这里设置了一个基类引用,对应是派生类地址,这一做法之前没想过,建议去看看,看是不是只是为了说明该静态联编的效果(目前看来这一做法正是多态性的体现).

(二) 虚函数

1 理解

刚才的多态,联编中已经提到了虚函数,此处做更具体理解.

虚函数的实现原理:

编译器在编译时,给每个对象添加一个隐藏成员,隐藏成员中有一个指向函数地址数组的指针(vtpr),这个函数数组叫虚函数表(vtbl),表中存有虚函数的地址.?

基类对象包含有指针指向基类虚函数的地址表,派生类对象也有包含指向派生类中虚函数的指针,如果派生类对象重新定义了该虚函数,则虚函数表将保存新的虚函数地址.

此处借用c++ primer 中的一个图片,图片是一种虚函数机制,且非常直观.

从以上机制也可以看到(一)中说的动态联编开销大在哪里:

1 多了一个虚函数地址表,保存函数的地址.

2 多了一个存有表的地址的指针.

3 执行虚函数调用时需要多一个查表地址的过程.

2 代码段

class Manager
{
private:
    int x,y;

public:
    Manager(int x=0,int y=0)
    {
        this->x = x;
        this->y = y;
    }
    virtual double Money()//设置为虚函数
    {
        return x*y;
    }
};

3 结果与说明

?调用的正是我们想要的函数,可以看到虚函数机制的作用.

(三) 虚析构函数

1 理解

? ? ? ?虚析构函数是将基类的析构函数申明为虚函数,当用基类的指针指向派生类的对象四方式,可以根据实际所指的对象调用相应的析构函数,先释放派生类对应的空间,后会调用基类析构函数(此为编译器所规定),若不申明为虚函数,由(二)中说明就知道,由于是静态联编,将只会调用基类的析构函数,则派生内相应的内存将不被释放,造成内存泄露.

? ? ? ?构造函数没有虚函数,调用构造函数需要在实例化对象时,而根据之前的虚函数的实现机制,虚函数是根据虚函数表与表中的虚函数指针来调用函数的,若未实例化,自然没有相应的虚函数表,自然也没有虚构造函数,从虚函数的功能角度讲也没意义,因为虚函数是实现的是若基类指针指向派生类对象,能够调用合适的函数,而构造函数本来就在实例化对象时调用来初始化对象的数据成员.

2 代码

#include <iostream>

using namespace std;
#define Huilv 0.9
class Manager
{
private:
    int x,y;
    char *str;
public:
    Manager(int x=0,int y=0)
    {
        this->x = x;
        this->y = y;
    }
    virtual double Money()
    {
        return x*y;
    }
    ~Manager()
    { delete []str;
       cout<<"Destucted main success"<<endl;
    }
};
class Employee:public Manager
{
private:
    int r;
    char *str;
public:
    Employee(int x,int y,int z):Manager(x,y)
    {
        r = z;
        str=new char[100];
    }
    double Money()
    {
        return Huilv*r;
    }
    ~Employee()
    {
        delete []str;
        cout<<"destruced Employee success"<<endl;
    }
};

int main()
{
    Manager *p;
    p=new Employee(1,1,1);
    delete p;
    return 0;
}

结果与说明

 virtual ~Manager()
    { delete []str;
       cout<<"Destucted main success"<<endl;
    }
};

3 结果与说明

?可以很明显地通过对比看到虚析构函数的作用.

(四) 纯虚函数与抽象类

1 理解

从内容上没有函数体的虚函数,从形式上,定义时后面加了"=0".

抽象类是指含有纯虚函数的类。

为什么会引入纯虚函数这样一个东西，这要拿抽象类来说：

抽象类可以为外界提供一个高度抽象与统一的接口，它不可以实例化对象，不可作为参数类型，返回值，强制转换的类型。它可以定义指针或者引用，来指向派生类从而实现多态性（建议对此句通过理论与实践更进一步地理解）。

更具体的例子比如在一个类中，定义了几个函数，其中一个函数是Student（），为什么设置为虚函数呢，因为在这个层次看来，该Student只是个Student，看不到它的具体工作，可以在其派生类中具体定义派生类的功能。

2 代码

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

class Person
{
public:
    Person(string name);
    virtual void work()=0;
private:
    string m_strname;
};
Person::Person(string name)
{
    m_strname=name;
}
class Student:public Person
{
public:
    Student(string name);
    virtual void work()=0;
private:
    string m_strname;
};
Student::Student(string name):Person(name)
{
;
}
class Junior:public Student
{
public:
    Junior(string name);
    virtual void work()
   {
       cout<<"A"<<endl;
    }
private:
    string m_strname;
};

Junior::Junior(string name):Student(name)
{
    ;
}
int main()
{
    Junior A("Lerbon");
   A.work();
    return 0;
}