C++多态总结:多态原理、虚函数指针、重载重写 ,赋值兼容性原则



问题引出:赋值兼容性遇上函数重写

#include "iostream"

using namespace std;

//定义一个子类和一个父类

class Parent

{

public:

         Parent(int a = 0)

         {

                   this->a = a;

         }

         Virtual void print()

         {

                   cout<<"父类a:"<<a<<endl;

         }

protected:

private:

         int a;

};

class Child : public Parent

{

public:

         Child(int b = 0)

         {

                   this->b = b;

         }

                   void print()

         {

                   cout<<"子类b:"<<b<<endl;

         }

protected:

private:

         int  b;

};

//面向对象新需求

//如果我传一个父类对象,执行父类的print函数

//如果我传一个子类对象,执行子类的printf函数

 

 

//现象产生的原因

//赋值兼容性原则遇上函数重写 出现的一个现象

//1 没有理由报错

//2 对被调用函数来讲,

//3 在编译器编译期间,我就确定了,这个函数的参数是p,是Parent类型的。。。

//静态链编

void HowToPrint1(Parent *p)

{

         p->print(); //一句话,有多种效果,有多种表现形态把。。。//这个功能的就是多态

}

void HowToPrint2(Parent &myp)

{

         myp.print();

}

void main()

{

         Parent p1;

         Child c1;  

         Parent *p = NULL;

         p = &p1;

         p->print(); //调用父类的打印函数

         //赋值兼容性原则 遇上 同名函数的时候

         p = &c1;

         p->print(); //    

         HowToPrint1(&p1);

         HowToPrint1(&c1);

 

         HowToPrint2(p1);

         HowToPrint2(c1);

         system("pause");

}

多态的理解

角度1

p->print(); //一句话,有多种效果,有多种表现形态把。。。//这个功能的就是多态

角度2

 

 

 

1、面向对象新需求

编译器的做法不是我们期望的

         根据实际的对象类型来判断重写函数的调用

         如果父类指针指向的是父类对象则调用父类中定义的函数

         如果父类指针指向的是子类对象则调用子类中定义的重写函数

 

 

2C++提供的多态解决方案

  • C++中的多态支持

  • C++中通过virtual关键字对多态进行支持

  • 使用virtual声明的函数被重写后即可展现多态特性

     

3、重载、重写、重定义

函数重载

必须在同一个类中进行

子类无法重载父类的函数,父类同名函数将被名称覆盖

重载是在编译期间根据参数类型和个数决定函数调用

函数重写

必须发生于父类与子类之间

并且父类与子类中的函数必须有完全相同的原型

使用virtual声明之后能够产生多态(如果不使用virtual,那叫重定义)

多态是在运行期间根据具体对象的类型决定函数调用

 

经典易错:

 

 

 

class Parent01

{

public:

         Parent01()

         {

                   cout<<"Parent01:printf()..do"<<endl;

         }

public:

         void func()

         {

                   cout<<"Parent01:void func()"<<endl;

         }

         void abcd()

         {

                   cout<<"Parent01:void func()"<<endl;

         }

         virtual void func(int i)

         {

                   cout<<"Parent:void func(int i)"<<endl;

         }

         virtual void func(int i, int j)

         {

                   cout<<"Parent:void func(int i, int j)"<<endl;

         }

};

//重写的两种情况

//如果函数重写,在父类中增加了virtual关键字, 将能产生多态。。。。

//如果函数重写,没有加virtual关键字,,相当于在子类中重定义。。。。。,不会发生多态。。。

class Child01 : public Parent01

{

 

public:

//原因是发生了 名称覆盖,把子类中的没有函数参数的,这个函数abcd名称覆盖了

         //在子类中,是不能重载父类的函数的。编译器就是这么做的,顺从。。。。

         void abcd(int a, int b)

         {

                   cout<<"Parent01:void func()"<<endl;

         }

         //此处2个参数,和子类func函数是什么关系

          void func(int i, int j)

         {

                   cout<<"Child:void func(int i, int j)"<<" "<<i + j<<endl;

         }

 

         //此处3个参数的,和子类func函数是什么关系

         void func(int i, int j, int k)

         {

                   cout<<"Child:void func(int i, int j, int k)"<<" "<<i + j + k<<endl;

         }

};

int main()

{

         Parent01 p;

         p.func();

         p.func(1);

         p.func(1, 2);

         Child01 c;

         c.Parent01::abcd(); //这个函数是从父类中继承而来 可以使用。。。

//子类和父类有相同的名字(变量名字或者是函数名字的时,子类名字覆盖父类名字,如果想使用父类的资源,需要加::

         //c.func(); //问题1这个函数是从父类中继承而来,为什么这个地方不能使用

         //c.func(1, 2); 

         system("pause");

         return 0;

}

 

//问题1child对象继承父类对象的func,请问这句话能运行吗?why

//c.func();

//1子类里面的func无法重载父类里面的func

//2当父类和子类有相同的函数名、变量名出现,发生名称覆盖

//3//c.Parent::func();

//问题2 子类的两个func和父类里的三个func函数是什么关系?

 

 

 

 

4、多态的实现原理以及多态的理解

多态的实现效果

多态:同样的调用语句有多种不同的表现形态;

多态实现的三个条件

         有继承、有virtual重写、有父类指针(引用)指向子类对象。

多态的C++实现

   virtual关键字,告诉编译器这个函数要支持多态;不要根据指针类型判断如何调用;而是要根据指针所指向的实际对象类型来判断如何调用
多态的理论基础

   动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。

多态的重要意义

   设计模式的基础。

实现多态的理论基础

  函数指针做函数参数

 

C++中多态的实现原理

当类中声明虚函数时,编译器会在类中生成一个虚函数表

虚函数表是一个存储类成员函数指针的数据结构

虚函数表是由编译器自动生成与维护的

virtual成员函数会被编译器放入虚函数表中

存在虚函数时,每个对象中都有一个指向虚函数表的指针(vptr指针)

说明1

通过虚函数表指针VPTR调用重写函数是在程序运行时进行的,因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上,虚函数的效率要低很多。

说明2

出于效率考虑,没有必要将所有成员函数都声明为虚函数

 

5、多态原理研究(证明VPTR指针的存在)

 

C++编译器内部实现的时候,通过virtual关键字,内部帮我们在父类子类添加了虚函数指针和虚函数表,以下是证明虚函数指针的存在的方法

#include "iostream"

using namespace std;

 

class AA

{

public:

         virtual void print()

         {

                  printf("dddd\n");

         }

protected:

private:

         int b;

};

void main()

{

         printf("AA%d \n", sizeof(AA));    //8VPTR4字节,b字节

         system("pause");

}

 

6、虚函数表指针(VPTR)被编译器初始化的过程

 

对象在创建的时,由编译器对VPTR指针进行初始化

只有当对象的构造完全结束后VPTR的指向才最终确定

父类对象的VPTR指向父类虚函数表

子类对象的VPTR指向子类虚函数表

 

7、为什么要定义虚析构函数

//在父类中声明虚析构函数的原因

//通过父类指针,把所有的子类析构函数都执行一遍。。。

void howtoDel(Parent *pbase)

{

         delete pbase;

}

void mainobj()

{

         Parent *p1 = new Parent();

         p1->print();

         delete p1;

}

void main()

{

         Child *pc1 = new Child();

         howtoDel(pc1);

         //mainobj();

         system("pause");

}

 

8、基类和子类对象指针++混搭风

 

class Parent01

{

protected:

         int i;

         int              j;

public:

         virtual void f()

         {

                   cout<<"Parent01::f"<<endl;

         }

};

//一次偶然的成功,比必然的失败更可怕

class Child01 : public Parent01

{       

public:

         int k;

public:

         Child01(int i, int j)

         {

                   printf("Child01:...do\n");

         }

         virtual void f()

         {

                   printf("Child01::f()...do\n");

         }

};

void howToF(Parent01 *pBase)

{

         pBase->f();      

}

int main()

{

         int i = 0;

         Parent01* p = NULL;

         Child01* c = NULL;

         //可以使用赋值兼容性原则,是用在多态的地方

         //不要轻易通过父类指针p++,来执行函数操作

         //问题的本质 子类指针 和父类指针 步长可能不一样。。。

         Child01 ca[3] = {Child01(1, 2), Child01(3, 4), Child01(5, 6)};

         p = ca; //第一个子类对象赋值给pp是基类指针,

         c = ca;

         p->f(); //有多态发生

         //c->f(); //

         p++;

         //c++;

         p->f();//有多态发生

        //c->f()

//     for (i=0; i<3; i++)

//     {

//              howToF(&(ca[i]));

//     }

         system("pause");

         return 0;

}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值