7-30复习 多态

如果子类定义了与父类中原型相同的函数会发生什么？

函数重写
在子类中定义与父类中原型相同的函数
函数重写只发生在父类与子类之间

重载与重写区别：
重载：同一个作用域；
      子类无法重载父类函数，父类同名函数将被覆盖；
      重载是在编译期间根据参数类型和个数决定；
重写：发生于父类、子类之间；
      父类和子类函数有相同的函数原型；
      使用virtual关键字声明后能够产生多态；
      运行期间根据具体对象类型决定调用的函数。

 ----注意：

根据实际的对象类型来判断重写函数的调用
如果父类指针指向的是父类对象则调用父类中定义的函数
 如果父类指针指向的是子类对象则调用子类中定义的重写函数

 

/*
#include <iostream>
#include <windows.h>
using namespace std;

class A
{
public:
    void print()
    {
        cout << "AAAAA" << endl;
    }
};

class B : public A
{
public:
    void print()
    {
        cout << "BBBBB" << endl;
    }
};

int main()
{
    A *pa = new A;            //基类指针指向基类对象
    pa->print();

    delete pa;
    pa = new B;                //基类指针指向派生类对象
    pa->print();            //输出还是A 编译时就决定了  因为指针类型是 A

    system("pause");
    return 0;
}
*/

/*
#include <iostream>
#include <windows.h>
using namespace std;

class A
{
public:
    virtual void print()
    {
        cout << "AAAAA" << endl;
    }
};

class B : public A
{
public:
    void print()
    {
        cout << "BBBBB" << endl;
    }
};

int main()
{
    A *pa = new A;        //基类指针指向基类对象
    pa->print();

    delete pa;
    pa = new B;            //基类指针指向派生类对象
    pa->print();        //输出是B 这时候基类的print函数为虚函数 继承时隐藏了

    system("pause");
    return 0;
}
*/

/*
#include <iostream>
#include <string>
using namespace std;

class A
{
public:
    int m_a;
    ~A()
    {
        cout << "~~A" << endl;
    }
};

class A1 :virtual public A
{
public:
    int m_a1;
    A1(int a1)
    {
        m_a1 = a1;
        cout << "A1" << endl;
    }
    ~A1()
    {
        cout << "~~A1" << endl;
    }

};

class A2 :virtual public A
{
public:
    int m_a2;
    A2(int a2)
    {
        m_a2 = a2;
        cout << "A2" << endl;
    }
    ~A2()
    {
        cout << "~~A2" << endl;
    }
};

class C :public A1, public A2
{
public:
    int m_c;
    C() : A1(1), A2(2)
    {
        
        cout << "CCCCCCCCC" << endl;
    }
    ~C()
    {
        cout << "~~CCCCCCCCC" << endl;
    }
};

int main()
{
    C b;
    A *pa = &b;
    A1 *pa1 = &b;
    A2 *pa2 = &b;

    cout << &b << endl;
    cout << pa << endl;
    cout << pa1 << endl;
    cout << pa2 << endl;

    cout << "************" << endl;

    system("pause");
    return 0;
}
*/

/*
#include <iostream>
#include <windows.h>
using namespace std;

class A
{
protected:
int m_len;
public:
A(int l);
virtual ~A();                //虚析构函数 作用;父类指针释放子类空间

};

A::A(int l)
{
cout << "constuctor A ok ~" << endl;
m_len = l;
}

A::~A()
{
cout << "destuct A ok~" << endl;
}

class Array : public A
{
private:
char *m_data;
public:
Array();
~Array();

};

Array::Array() : A(5)
{
m_data = new char[m_len];
cout << "constuct Array ok ~" << endl;
}

Array::~Array()
{
delete m_data;
cout << "destuctr Array ok ~" << endl;
}

int main()
{
A *a1 = new Array;

delete a1;

cout << &a1 << endl;

system("pause");
return 0;
}
*/

//***************virtual 加在 public 继承上 就是 虚指针
//************virtual 加在 基类函数 上 就是 虚函数表指针

/*
#include <iostream>
#include <windows.h>

using namespace std;

class A
{
protected:
    int m_a;
public:
    A();
    virtual void print();
};

A::A()
{
    m_a = 1;
}

void A::print()
{
    
}

class B : public A
{
private:
    int m_b;
public:
    B(int b);
    void print();
};

B::B(int b)
{
    m_b = b;
}

void B::print()
{
    cout << "m_b = " << m_b << endl;
}

int main()
{
    B b[5] = {B(1),B(2), B(3),B(4), B(5)}; //派生类对象数组
    //每个B里有三个元素 一个指针 一个m_a 一个m_b
    A *pa = b;//不能用基类指针指向派生类数组，因为步长不一样

    //b[2].print();
    //pa[2].print();//访问会出错

    cout << pa << endl;
    cout << b << endl;

    cout << pa + 1 << endl;
    cout << b + 1 << endl;

    system("pause");
    return 0;
}
*/

/*
#include <iostream>
#include <windows.h>

using namespace std;

class A                        //含有纯虚函数的类 叫做 抽象类  //所以抽象类 无法创建对象
{
protected:
    int m_a;
public:
    A();
    virtual void print() = 0;//纯虚函数 要求任何派生类都要定义 自己的版本
                                //如果 派生类不实现 那么 她还是一个抽象类
};

A::A()
{
    m_a = 1;
}

class B : public A
{
private:
    int m_b;
public:
    B(int b);
    void print();
};

B::B(int b)
{
    m_b = b;
}

void B::print()
{
    cout << "m_b = " << m_b << endl;
}

int main()
{
    B b[5] = { B(1), B(2), B(3), B(4), B(5) }; //派生类对象数组
    //每个B里有三个元素 一个指针 一个m_a 一个m_b
    A *pa = b;//不能用基类指针指向派生类数组，因为步长不一样

    //b[2].print();
    //pa[2].print();//访问会出错

    cout << pa << endl;
    cout << b << endl;

    cout << pa + 1 << endl;
    cout << b + 1 << endl;

    system("pause");
    return 0;
}
*/