继承与多态下

重载与重写区别？

class Parent
{
public:
    virtual void func()	//1
    {
        cout<<"void func()"<<endl;
    }
    virtual void func(int i) //2 
    {
        cout<<"void func(int i)"<<endl;
    }
    virtual void func(int i, int j) //3
    {
        cout<<"void func(int i, int j)"<<endl;
    }
};
class Child : public Parent
{
public:
    void func(int i, int j) //4
    {
        cout<<"void func(int i, int j)"<<" "<<i + j<<endl;
    }
    void func(int i, int j, int k) //5
    {
        cout<<"void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
    }
};
void run(Parent* p)
{
    p->func(1, 2);
}

int main(int argc, char *argv[])
{
    Parent p;	//123重载，无继承暂时忽略virtual关键字 
    p.func();
    p.func(1);
    p.func(1, 2);
    
    Child c;	//45重载，34重写，4可不加virtual 
    //c.func();	报错,1与4间无重载关系，重载只发生在相同作用域内 
    c.Parent::func();	//名称覆盖 
    c.func(1, 2);
    
    run(&p);
    run(&c);
    return EXIT_SUCCESS;
}

结果：
void func()
void func(int i)
void func(int i, int j)
void func()
void func(int i, int j) 3
void func(int i, int j)
void func(int i, int j) 3
函数重载：
发生在同一作用域
子类无法重载父类的函数，父类同名函数将被覆盖
重载是在编译期间根据参数类型和参数个数决定调用哪个函数(效率高)
函数重写
发生在父类与子类间
有完全相同的函数原型
使用virtual关键字声明
多态是在运行期间根据具体对象类型决定调用哪个函数
------/是否可将类的所有函数均声明为虚函数？ 
C++多态实现原理：
 当类中声明虚函数时，编译器会在类中生成一虚函数表
 虚函数表是一存储类虚函数函数指针的数据结构
 虚函数表由编译器自动生成与维护
 virtual成员函数会被编译器放入虚函数表
 存在虚函数时，每个对象都有一指向虚函数表的指针

void run(Parent* p)
{
    p->func();
}

编译器确定func()是否为虚函数？
是，则编译器在对象VPTR所指向虚函数表中查找func()并调用，查找和调用在运行时完成
否，编译器直接可确定并找到被调用的成员函数

通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，需通过寻址操作才能确定真正应调用的函数，效率要低很多，故没必要将所有成员函数都声明为虚函数
Java、c#无虚函数概念，但其只要重写均隐式被定义为虚函数(从c++观点看)，均可发生多态，影响效率
对象中VPTR指针什么时候被初始化？
对象在创建时由编译器对VPTR指针进行初始化， 只有当对象构造完全结束后VPTR指向才最终确定，父类对象VPTR指向父类虚函数表，子类对象VPTR指向子类虚函数表
结论： 构造函数中调用虚函数无法实现多态

class Parent
{
public:
    Parent()
    {
        this->func();		//对象构造未结束
    }
    virtual void func()
    {
        cout<<"void Parent::func()"<<endl;
    }
};
class Child : public Parent
{
public: 
    void func()
    {
        cout<<"void Child::func()"<<endl;
    }
};

int main(int argc, char *argv[])
{
	Parent p;
    Child c;	//创建子类对象，会调用父类构造函数，其this指向子类对象
    return EXIT_SUCCESS;
}

结果：
void Parent::func()
void Parent::func()
------/纯虚函数
抽象类可表示现实世界中的抽象概念，其不能产生对象，只能用于定义指针和引用，或被继承并重写相关函数，直接特征是纯虚函数
纯虚函数是只声明函数原型，而不定义函数体的虚函数

class Shape
{
public:
    virtual double area()=0;		//纯虚函数，= 0告诉编译器该函数故意只声明不定义
};

class Rectangle : public Shape
{
    double m_a;
    double m_b;
public:
    Rectangle(double a, double b)
    {
        m_a = a;
        m_b = b;
    }
    virtual double area()
    {
        return m_a * m_b;
    }
};

class Circle : public Shape
{
    double m_r;
public:
    Circle(double r)
    {
        m_r = r;
    }
    virtual double area()
    {
        return 3.14 * m_r * m_r;
    }
};

void area(Shape* s)
{
    cout<<s->area()<<endl;
}

int main(int argc, char *argv[])
{
    Rectangle rect(2, 3);
    Circle circle(4);
    area(&rect);
    area(&circle);
    return EXIT_SUCCESS;
}

结果：
6
50.24
若不使用抽象类，写为：

class Shape
{
public:
    virtual double area()
    {
    	return 0;
    }
};

可工作，但会出现"计算图形面积"此类不合逻辑事件，如：
Shape s; area(&s); //结果为0