第九天2017/04/18（3、重载/覆盖 PK 重写/重定义、父类子类混搭风、抽象类）

1、重载/覆盖 PK 重写/重定义
【预备知识】
函数重载
    必须在同一个类中发生
    子类无法重载父类的函数，父类同名的函数将会被名称覆盖
    重载是在编译期间根据参数类型和个数决定函数调用
    重载只放在同一个类之中，在编译期间就确定
函数重写
    必须发生在父类与子类之间
    父类与子类中的函数必须有完全相同的函数原型
    使用virtual关键字声明后能够产生多态（如果没有virtual，那叫重定义）
    多态是运行期间根据具体对象的类型决定函数调用
    重写发生在父子类之间，
覆盖
    父类和子类中有“同名”的函数，子类的函数会把父类的函数隐藏起来
重定义（是一种特殊的覆盖）
    父类和子类中有“相同函数原型”的函数，子类的函数会把父类的函数隐藏起来
1、重载/覆盖 PK 重写/重定义
    重载：在“同一个类”中，函数名相同、函数原型不同，此时发生重载
    覆盖：无virtual关键字，在父类、子类中，函数名相同、函数原型不同，此时在子类中的函数隐藏了父类中的函数。
---------------------------------------------------------------------------------------------
    重写：有virtual关键字，在父类、子类中，函数名、函数原型都相同，此时发生重写
    重定义：无virtual关键字，在父类、子类中，函数名、函数原型都相同，此时在子类中的函数隐藏了父类中的函数，类似于“覆盖”。

#include <iostream>
using namespace std;
class B
{
public:
    void f() {  }
    virtual void f(int i) {  } 
    void f(int i,int j) {  }
};
class D:public B
{
public:
    //子类中没有void f()函数
    void f(int i) {  }  //重写
    void f(int i,int j) {  }  //发生名称覆盖
    void f(int i,int j,int k) {  }  //发生名称覆盖
};
void g(B& b)
{
    b.f(1);
}

void main()
{
    D d;
/***************************************************************************/
//【重点】
//疑问：为什么子类对象不能调用父类中的f()函数？
//答：因为子类中有函数名为f的函数，有由于子类的函数不会重载父类的函数，所以
//子类中的f函数会把父类中的无参的f()函数给覆盖，因此直接d.f()会发生编译错误！
    //d.f();//error: 没有重载函数接受0个参数的f()
//疑问：如果我就是想用子类对象去调用父类中的f()函数，应该怎么做？
//答：加上作用域符B::，此时d对象就会调用父类B中的f()函数。
    d.B::f();  //
//【结论】子类中的f()函数不会重载父类中的f()函数，父类同名的函数将被覆盖！重载只发生在同一个类中！
/***************************************************************************/
    D dd;
//覆盖
    //dd.f();   //编译失败，因为无virtual发生同名覆盖
    dd.B::f();  //作用域B::，调用子类中的void f()
//覆盖、重定义
    dd.B::f(1,2);//作用域B::，调用子类中的void f(int i,int j)
    dd.f(1,2);  //覆盖：调用子类中的void f(int i,int j)
//多态
    B &b = d;
    b.f(1);     //多态：调用子类中的void f(int i)
    b.B::f(1);  //作用域B::，调用父类中的void f(int i)
//重载
}
----------------------------------------------------------------------
2、父类对象、子类对象混搭风【该模块中，隐藏了一个天大的Bug：“P++步长”】

本质：由于步长的影响
【结论】
        不要用父类指针p指向子类对象的数组，通过p++，去
    遍历这个子类对象的数组。
同理：也不要用子类指针p指向父类对象的数组，通过p++，去
    遍历这个父类对象的数组
【为什么？】因为父类指针p指向了子类对象的数组，在进行p++的时候，
p增加的步长是sizeof(父类)，但是由于sizeof(父类)不一定等于sizeof(子类)，
因此p在进行加1后，指向的位置不一定是下一个子类对象的首地址。当p指向的位置
不是下一个子类对象的首地址的时候，如果进行访问子类对象中的成员，程序必然会发生
崩溃。
//程序案例
#include <iostream>
using namespace std;
class A
{
public:
    virtual void f()
    {
        cout<<"A:f()"<<endl;
    }
};
class B:public A
{
public:
    int i;  //为什么在子类中加上一个属性i，程序就会运行崩溃：因为加了一个变量，对步长有影响
public:
    B(int i=0,int j=0){}
    virtual void f()
    {
        cout<<"B:f()"<<endl;
    }
};

void howToF(A* pBase)
{
    pBase->f();
}

int main()
{
    A *p = NULL;
    B *q = NULL;

    B c[3] = {B(1,1),B(1,1),B(1,1)};

    p = c; //父类指针p指向由子类对象构成的数组
    q = c; //子类指针q指向由子类对象构成的数组

    for(int i=0;i<3;i++)
    {
        //p->f();  //因为步长的原因，访问成员时，会发生程序崩溃
        q->f();

        p++;  //p++增加的步长是sizeof(父类)，而不是sizeof(子类)
        q++;
    }

    for(int i=0;i<3;i++)
    {
        howToF(&c[i]); //形参：子类对象的地址，实参：父类指针
         //解释：此处运行正确，为什么？
//此处没有用p++形式，而是用了下标操作c[i]，避开了p++的步长不一致导致的程序崩溃。
    }
    return 0;
}
----------------------------------------------------------------------
3、抽象类
#include <iostream>
using namespace std;
class A
{
public:
    virtual void ff() = 0;
};

//A  g1();  //不允许使用返回抽象类 "A" 的函数
A& g21();  //允许使用返回抽象类引用类型 "A&" 的函数
A& g22(A&); 
A& g23(A*); 
A* g31();  //允许使用返回抽象类指针类型 "A*" 的函数
A* g32(A*);
A* g32(A&);

//void f1(A  a);//不允许使用抽象类类型 "A" 的参数
void f2(A &a);//允许使用抽象类引用类型 "A&" 的参数
void f2(A *a);//允许使用抽象类指针类型 "A*" 的参数

class B:public A
{
public:
    void ff() {  }
};
int main()
{
    //A a1;//不能实例化抽象类
    //A a2 = new A;//不能实例化抽象类
    A *a4 = new B; //可以用抽象类的指针指向抽象类的子类对象

    B b1;
    A &a3 = b1;//可以用抽象类的引用指向抽象类的子类对象
}

4、多重继承与抽象类--->实现多继承接口
【知识复习】
#include <iostream>
using namespace std;
class A1
{
public:
    virtual void ff() = 0;  //纯虚函数
    void gg() { cout<<"普通函数"<<endl; }  //普通函数在A1中实现
};
class A2
{
public:
    virtual void ff() = 0;  //纯虚函数
    void gg() { cout<<"普通函数"<<endl; }//普通函数在A2中实现
};
class B:public A1,public A2//B多重继承A1、A2时
{
public:
    virtual void ff() //纯虚函数ff在B中实现
    { cout<<"纯虚函数"<<endl; }

};
int main()
{
    B b;
//b访问纯虚函数ff,不会发生二义性
    b.ff(); 
//b访问普通函数gg，会发生二义性
    //b.gg(); //编译失败
//防止二义性，应该加上作用域标识符A1::、A2::
    b.A1::gg();
    b.A2::gg();
}
【知识引出】
疑问：多重继承会发生二义性，但是多重继承在C++中有什么作用呢？
答：在项目开发过程中，多重继承的作用主要是：多重继承多个抽象类（接口），这样会有效的避免二义性。

多继承接口案例
#include <iostream>
using namespace std;
class A
{
public:
    virtual void ff(){ cout<<"ff:A"<<endl; }
};

class interface1 //抽象类接口1
{
public:
    virtual void gg1() = 0; 
};
class interface2 //抽象类接口2
{
public:
    virtual void gg2() = 0;  
};
class B:public A,public interface1,public interface2
{
//B类继承了类A、接口interface1、接口interface2
public:
    void gg1() { cout<<"gg1"<<endl; }
    void gg2() { cout<<"gg2"<<endl; }
    void kk(){ cout<<"KK"<<endl; }
};
int main()
{
    B b;
    b.ff();
    b.gg1();
    b.gg2();
    b.kk();
}