C++ 类(多态(2))

文章概述

1.重载,重写,重定义;
2.多态的原理;
3.证明vptr指针的存在;
4.构造函数中调用虚函数,能实现多态吗？
5.父类指针步长是否和子类指针步长一样？

---

重载,重写,重定义

a. 重载:(1)必须在同一个类中进行;(2)子类无法重载父类的函数,父类的同名函数会被子类的相同函数名所覆盖。

class A
{
public:
    int a; 
public:
    A()
    {
        a = 5;
        cout << "A" << endl;
    }
    void printF()
    {
        cout << a << "A" << endl;
    }
    virtual ~A()
    {
        cout << "~A" << endl;
    }
};

class B:public A  
{
public:
    int b;
public:
    B()
    {
        b = 10;
        cout << "B" << endl;
    }
    void printF()  
    {
        cout << b << "B" << endl;
    }
    //这种方式也会覆盖父类的同名函数
    //int printF()  
    //{
    //  cout << b << "B" << endl;
    //  return 0;
    //}
    ~B()
    {
        cout << "~B" << endl;
    }
};

int main()
{
    B b;
    b.printF();
    return 0;
}

(3)函数重载是在编译期间根据函数的类型和个数决定函数调用。
b. 函数重写: (1)必须发生在父类和子类之间;(2)父类和子类的函数必须具有相同的函数原型(函数返回值,参数,函数名);(3)如果父类的同名函数用virtual声明,则会产生多态;不使用virtual声明,则叫重定义。多态则是在程序的运行期间根据对象的实际类型调用函数。

---

多态的原理

a. 当类的成员用virtual修饰时(包括继承中的virtual public A),C++编译器会提前布局,在成员变量中添加一个vptr指针。(创建对象的时候初始化vptr指针,和虚函数表联系)
b. 在产生vptr指针的同时,也会在类中产生一个虚函数表(存储虚函数指针的数据结构),虚函数表示由编译器自动生成和维护的。virtual成员函数会被C++编译器放入虚函数表中。(即存在虚函数时,每个对象都有一个指向虚函数的指针——>vptr指针)。
c. 实例分析:

C c;  //子类创建对象
P*p =&c;
p->print();  

当执行到p->print()时,C++编译器不需要区分print()函数时父类还是子类。只会确定prinrt()是否是虚函数:
a.不是,C++编译器直接会确定被调用的成员函数(静态编译,编译的时候根据P确定类型);
b. 是, 编译器会根据对象p的vptr指针,所指的虚函数表中查找print()函数,调用。（查找和调用在程序运行的时候进行的,实现动态编译）
注意: 没有必要将所有的成员函数设为虚函数？
通过虚函数表和vptr调用重写函数是在程序运行的时候进行的,需要通过寻址操作才能确定真正应该要调用的函数。但是普通函数在程序编译的时候就已经确定了要调用的函数,因此虚函数在效率要慢与普通的函数。从效率考虑,没有必要将所有的成员函数设为虚函数。

---

证明vptr指针的存在

class A
{
    int x;
public:
    void Print()
    {

    }
};

class B
{
    int y;
public:
    virtual void Print()  //会在成员变量中添加一个vptr指针
    {

    }
};

int main()
{
    cout << "A-------->" << sizeof(A) << endl;  //4
    cout << "B-------->" << sizeof(B) << endl;  //8
}

---

构造函数中调用虚函数,能实现多态吗

上面这句话是定义一个子类对象,在这个过程中父类的构造函数中调用虚函数,能实现多态吗？

class A
{
    int x;
public:
    A()
    {
        x = 10;
        //cout << "A" << endl;
        Print();   //父类的构造函数中调用虚函数,不会产生多态
    }
    virtual void Print()
    {
        cout << "A" << endl;
    }
};

class B:public A
{
    int y;
public:
    B()
    {
        y = 10;
        //cout << "B" << endl;
    }
    virtual void Print()  //会在成员变量中添加一个vptr指针
    {
        cout << "B" << endl;
    }
};

int main()
{
    B b;
    return 0;
}

为了说明子类的vptr指针的初始化时分步的。

---

父类指针步长是否和子类指针步长一样

a. 步长:根据类普通成员变量的个数计算的,因为类中,只有普通成员变量存储在对象中;
b. 指针的步长是根据定义指针的类型决定的。

class A
{
private:
    int a;
public:
    A()
    {
        this->a = 1;
    }
    virtual void print()
    {
        cout << "A" << endl;
    }
};

class B:public A
{
private:
    int b;
public:
    B(int b)
    {
        //this->b = b;
    }
    virtual void print() 
    {
        cout << "B" <<"  "/*<<b*/<< endl;
    }
    int getB()
    {
        return 0;
    }
};
int main()
{
    A* a = NULL;
    B* b = NULL;
    B arr[3] = { B(1),B(2),B(3) };
    a = arr;  //发生多态
    a->print();
    b = arr;
    b->print();//正常输出

    //----
    cout << "指针移动" << endl;
    b++;
    b->print();

    //----错误的,子类的步长有可能有父类的步长不同
    cout << "父类指针移动" << endl;
    a++;
    a->print();

    return 0;
}

结论: a.子类步长不同于父类的步长;
b. 不要将父类指针a++与子类的对象数组混用。