精华内容
下载资源
问答
  • 一、多态的概念 1、什么是多态? 多态指的是:同一种行为,对于不同的事物具有不同的表现形式。这就叫做多态。 举个例子: 老师给你布置1个任务,让你给老师找了3个人来。结果你给老师找了1个医生,1个演员,1个...

    ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

    一、多态的概念

    1、什么是多态?
    多态指的是:同一种行为,对于不同的事物具有不同的表现形式。这就叫做多态。
    举个例子:
    老师给你布置1个任务,让你给老师找了3个人来。结果你给老师找了1个医生,1个演员,1个理发师。  请问这样可以吗?当然可以,医生、演员、理发师他们都是人,完全符合老师的要求。好了,现在我向他们发出1个指令,我说你们都给cut.  让他们都去执行cut这个行为。
    医生会做什么?拿着手术刀就给你开刀。
    演员会做什么?立即停止表演,等着发盒饭。
    理发师会做什么?拿起剪刀就要给你剪头发。
    看到了吗?这3个人对于同1个行为(cut). 具有不同的表现形式  这就叫做多态。
    现实生活中多态的特点:
    1).在老师的眼里,他们三个我只当做人来看待。
    2).三个人具有共同的行为,但是他们每1个人的这个行为的实现是不一样的。
    3).给他们发送这个指令然后每1个人按照自己的实现方式去做。
    程序中的多态:不同的对象以自己的方式响应相同名称方法的能力称为多态
    2、多态的条件
    多态的条件:有继承关系、有方法重写
                父类的声明变量指向子类对象。
    //代码体现:用父类类型的指针指向了子类对象,这就是多态
    狗*g = [狗new];
    动物*a = [狗new];
    猫*c = [猫new];
    动物*a = [猫new];
    3、多态的优点
     多态的主要好处就是简化了编程接口。它容许在类和类之间重用一些习惯性的命名,而不用
    为每一个新加的函数命名一个新名字。这样,编程接口就是一些抽象的行为的集合,从而和实现
    接口的类的区分开来。
             多态也使得代码可以分散在不同的对象中而不用试图在一个函数中考虑到所有可能的对象。
    这样使得您的代码扩展性和复用性更好一些。当一个新的情景出现时,您无须对现有的代码进行
    改动,而只需要增加一个新的类和新的同名方法。

    二、多态的实现

    1、如何实现多态?

    Animal是父类,子类有Cat 和 Dog,子分别重写了父类中的eat方法;实例化对象的时候可以用下面的方法:
    Animal *animal = nil;
    //实例化猫的对象
    animal = [Cat new];
    [animal eat];
    //实例化狗的对象
    animal = [Dog new];
    [animal eat];

    创建一个类:

    #import<Foundation/Foundation.h>
    @intface Animal : NSObject
    -(void)run;
    @end
    实现这个类
    #import"Animal.h"
    @implementation Animal
    -(void)run{
    NSLog(@"动物在跑");
    }

    创建两个子类:Dog和Cat

    #import<Foundation/Foundation.h>
    @intface Dog : Animal
    -(void)run;         //此处可以不用写
    @end

    实现Dog类:

    #import"Dog.h"
    @implementation Dog
    -(void)run{
    NSLog(@"狗再跑");
    }
    Cat类:

    #import<Foundation/Foundation.h>
    @intface Cat : Animal
    -(void)run;         //此处可以不用写
    @end
    实现Cat类:

    #import"Cat.h"
    @implementation cat
    -(void)run{
    NSLog(@"猫在跑");
    }

    main函数实现:

    #import <Foundation/Foundation.h>
    #import "Animal.h"
    #import"Dog.h"
    #import"Cat.h"
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
    /*****************没有使用多态的情况**/
           Animal *ani = [Animal new];
    [ani run];
    Dog *dog = [Dog new];
    [dog run];
    Cat *cat = [Cat new];
    [cat run];
    /*****************使用多态的情况,父类指针指向了子对象**/
    Animal *a2 = [Dog new];
    [a2 run];
    Animal *a3 = [Cat new];
    [a3 run]; 
            
        }
        return 0;
    }

    2、多态的原理

    动态绑定:
                动态类型能使程序直到执行时才确定对象所属类型
                动态类型绑定能使程序直到执行时才确定要对对象调用的实际方法
               OC不同于传统程序设计语言,它可以再运行时加入新的数据类型和新的程序模块:动态类型识别,动态绑定,动态加载
         id类型:通用指针类型,弱类型,编译时不进行类型检查
    3、多态的注意点
    1)如果存在多态,父类是可以访问子类特有的方法

    如:

    @intface Dog : Animal
    -(void)run;         //此处可以不用写
    -(void)bark;       //子类特有的方法
    @end
    实现:

    @implementation Dog
    -(void)run{
    NSLog(@"狗再跑");
    }
    -(void)bark
    {
    NSLog(@"狗在叫");
    }

    在main 中:

    #import <Foundation/Foundation.h>
    #import "Animal.h"
    #import"Dog.h"
    int main(int argc, const char * argv[]) {
        @autoreleasepool {
    Animal *an2 = [Dog new];
       [(Dog*)an2 bark];  //把父类的指针,强制类型转换,从而父类访问子类方法
            
        }
        return 0;
    }

    2)如果不存在多态,父类是不可以访问子类特有的方法的

    Animal *an3 = [Animal new];
       [(Dog*)an3 bark]; //错误的,不能强制转换







    展开全文
  • **C#中什么是多态,多态的分类和实现多态的方式是什么?**一 : 多态的定义:二 :多态的类别:2.1 静态多态性2.2 动态多态性:三 :多态的几种实现方式: 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在...

    多态是面向对象的三大特性之一,所谓面向对象是指在编程时将任何事物都看成是一个对象来描述。 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在运行时发生的。

    一 : 多态的定义:

    同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。这就是多态,这种特性称为多态性。

    二 :多态的类别:

      多态性可以是静态的或动态的,再静态多态中,函数的响应是在编译时发生的。 在动态多态性中,函数的响应是在运行时发生的。

     2.1 静态多态性

       在编译时,函数和对象的连接机制被称为早期绑定,也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为:

    •  函数重载
    •  运算符重载
     2.2 动态多态性:

      C# 允许您使用关键字 abstract 创建抽象类,用于提供接口的部分类的实现。当一个派生类继承自该抽象类时,实现即完成。抽象类包含抽象方法,抽象方法可被派生类实现。派生类具有更专业的功能。

    三 :多态的几种实现方式:

    展开全文
  • 1. 多态的概念 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态 比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是...

    1. 多态的概念

    多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态

    比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是优先买票。

    2. 多态的定义及实现

    2.1多态定义的构成条件

    多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Student继承了Person。Person对象买票全价,Student对象买票半价

    在继承中要构成多态还有两个条件

    1. 调用函数的对象必须是指针或者引用。
    2. 被调用的函数必须是虚函数,且完成了虚函数的重写。

     什么是虚函数?

    虚函数:就是在类成员函数的前面加virtual关键字

    class Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票全价" << endl;
    	}
    };

    什么是虚函数重写?

    虚函数重写:派生类中有一个和基类完全相同的虚函数,我们就称子类的虚函数重写了基类的虚函数,完全相同是指:函数名,参数,返回值都相同。另外虚函数的重写也叫做虚函数的覆盖

    class Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票全价" << endl;
    	}
    };
    class Student :public Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票半价" << endl;
    	}
    };
    
    void Func(Person &people)
    {
    	people.BuyTicket();
    }
    
    int main()
    {
    	Person p;
    	Func(p);
    
    	Student s;
    	Func(s);
    
    	return 0;
    }

    虚函数重写的例外:协变

    虚函数重写有一个例外:重写的虚函数的返回值可以不同,但是必须分别是基类指针和派生类指针或者基类引用和派生类引用。

    class A
    {};
    
    class B :public A
    {};
    
    class Person
    {
    public:
    	virtual A* f()
    	{
    		return new A;
    	}
    };
    class Student :public Person
    {
    public:
    	virtual B* f()
    	{
    		return new B;
    	}
    };

     不规范的重写行为

    在派生类中重写的成员函数可以不加virtual关键字,也是构成重写的,因为继承后基类的虚函数被继承下来了在派生类一九保持虚函数特性,我们只是重写了它。但是这是非常不规范的,我们平时不要这样使用。

    class Person 
    { 
    public: 
    	virtual void BuyTicket() 
    	{ 
    		cout << "买票-全价" << endl;
    	}
    };
    
    class Student : public Person
    { 
    public: 
    	void BuyTicket() 
    	{ 
    		cout << "买票-半价" << endl; 
    	} 
    };

     析构函数的重写问题

    基类中的析构函数如果是虚函数,那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同,看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名字统一处理成destructor,这也说明的基类的析构函数最好写成虚函数。

    class Person 
    {
    public:
    	virtual ~Person() 
    	{
    		cout << "~Person()" << endl;
    	} 
    };
    
    class Student : public Person 
    { 
    public:
    	virtual ~Student()
    	{
    		cout << "~Student()" << endl;
    	}
    };
    
    // 只有派生类Student的析构函数重写了Person的析构函数,
    //下面的delete对象调用析构函数,才能构成多态,才能保证p1和p2指向的对象正确的调用析构函数。
    int main()
    {   
    	Person* p1 = new Person;
    	Person* p2 = new Student;
    	delete p1; 
    	delete p2;
    	return 0; 
    }

     接口继承和实现继承

    普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。所以如果不实现多态,不要把函数定义为虚函数。

    重载,覆盖(重写),隐藏(重定义)的对比

    3. 抽象类

    在虚函数的后面写上 =0;则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象。储蓄函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承。

    class Car
    {
    public:
    	virtual void Drive() = 0;
    };
    
    class Benz :public Car
    {
    public:
    	virtual void Drive()
    	{
    		cout << "Benz-舒适" << endl;
    	}
    };
    class BMW :public Car
    {
    public:
    	virtual void Drive()
    	{
    		cout << "BMW-操控" << endl;
    	}
    };
    int main()
    {
    	Car* pBenz = new Benz;
    	pBenz->Drive();
    
    	Car* pBMW = new BMW;
    	pBMW->Drive();
    }
    

    4.C++11中的 override 和 final

    C++11提供override和final来修饰虚函数。

    实际中我们建议多使用纯虚函数+override的方式来强制重写虚函数,因为虚函数的意义就是实现多态,如果没有重写,虚函数就没有意义。

     

    5. 多态的原理

    5.1虚函数表

    class Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Fun1()" << endl;
    	}
    private:
    	int _b = 1;
    };
    
    int main()
    {
    	cout << sizeof(Base) << endl;
    	//输出结果为8
    }

     上面程序运行的结构为8,除了_b成员,还多一个_vfptr放在对象的前面,对象中的这个指针我们叫做虚函数表指针(v代表virtual,f代表function)。一个含有虚函数的类中至少都有一个虚函数表的指针,因为虚函数的指针要被放到虚函数表中,虚函数表也简称虚表。

     

    //1.增加了一个派生类Derive去继承Base
    //2.Derive中重写Func1
    //3.Base再增加一个虚函数Fun2和一个普通函数Fun3
    class Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base::Fun2()" << endl;
    	}
    	void Fun3()
    	{
    		cout << "Base::Fun3()" << endl;
    	}
    private:
    	int _b = 1;
    };
    class Derive :public Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Derive::Fun1()" << endl;
    	}
    private:
    	int _d = 2;
    };
    
    int main()
    {
    	Base b;
    	Derive d;
    	//cout << sizeof(Base) << endl;  //8
    	//cout << sizeof(Derive) << endl; //12
    
    }

    我们发现:

    1. 派生类对象d中也有一个虚表指针,d对象由两部分构成,一部分是父类继承下来的成员,虚标指针也就是存在部分的另一部分是自己的成员。
    2. 基类b对象和派生类d对象虚表是不一样的,这里我们发现Fun1完成了重写,所以d的虚表中存的是重写的Derive::Fun1,所以虚函数的重写也叫覆盖,覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法,覆盖是原理层的叫法。
    3. 另外Fun2继承下来后是虚函数,所以放进了虚表,Fun3也继承下来了,但不是虚函数,所以不会放进虚表
    4. 虚函数表本质是一个存虚函数指针的指针数组,这个数组最后面放了一个nullptr
    5. 总结一下派生类的虚表生成:a.先将基类中的虚表内容拷贝一份到派生类虚标中 b.如果派生类重写了基类中某个虚函数,用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
    6. 虚表存的是虚函数指针,不是虚函数,虚函数和普通函数一样的,都存在代码段的,只是他的指针又存到了虚表中。另外对象中存的不是虚表,存的是虚标指针,虚表存在于数据段。

    5.2多态的原理

    class Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票全价" << endl;
    	}
    };
    class Student :public Person
    {
    public:
    	virtual void BuyTicket()
    	{
    		cout << "买票半价" << endl;
    	}
    };
    
    void Func(Person &people)
    {
    	people.BuyTicket();
    }
    
    int main()
    {
    	Person p;
    	Func(p);
    
    	Student s;
    	Func(s);
    
    	return 0;
    }

     

    1.  观察上图红色我们可以发现,people指向p时,people.BuyTicket在p的虚表中找到的虚函数是Person::BuyTicket.
    2. 观察上图蓝色我们可以发现,people指向s时,people.BuyTicket在s的虚表中找到的虚函数是Student::BuyTicket.
    3. 这样就实现除了不同对象去完成同一行为时,展示出不同形态
    4. 要达到多态,有两个条件,一个是虚函数的覆盖,一个是对象的指针会引用调用虚函数。
    5. 满足多态以后的函数调用,不是在编译时确定的,是运行起来以后到对象中去找的。不满足多态的函数调用是编译时确认好的。

     5.3 动态绑定与静态绑定

    1. 静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为,也称为静态动态,比如:函数重载
    2. 动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用具体的函数,也成为动态多态

    6. 单继承和多继承关系中的虚函数表

    6.1单继承中的虚函数表

    class Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base::Fun2()" << endl;
    	}
    private:
    	int a;
    };
    class Derive :public Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Derive::Fun1()" << endl;
    	}
    	virtual void Fun3()
    	{
    		cout << "Derive::Fun3()" << endl;
    	}
    	virtual void Fun4()
    	{
    		cout << "Derive::Fun4()" << endl;
    	}
    private:
    	int b;
    };
    
    int main()
    {
    	Base b;
    	Derive d;
    
    }

    观察监视窗口我们发现看不见Fun3和Fun4.这里是编译器的监视窗口故意隐藏了这两个函数,也可以认为他是一个小bug。

     我们可以打印出来虚表中的函数

    class Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base::Fun2()" << endl;
    	}
    private:
    	int a;
    };
    class Derive :public Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Derive::Fun1()" << endl;
    	}
    	virtual void Fun3()
    	{
    		cout << "Derive::Fun3()" << endl;
    	}
    	virtual void Fun4()
    	{
    		cout << "Derive::Fun4()" << endl;
    	}
    private:
    	int b;
    };
    typedef void(*VFPTR) ();
    void PrintVTable(VFPTR vTable[])
    {  
    	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    	cout << " 虚表地址>" << vTable << endl;  
    	for (int i = 0; vTable[i] != nullptr; ++i)  
    	{       
    		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]); 
    		VFPTR f = vTable[i];    
    		f(); 
    	}   
    	cout << endl; 
    }
    
    int main()
    {
    	Base b;
    	Derive d;
    	// 思路:取出b、d对象的头4bytes,就是虚表的指针,
    	//虚函数表本质是一个存虚函数指针的指针数组,这个数组最后面放了一个nullptr  
    	// 1.先取b的地址,强转成一个int*的指针 
    	// 2.再解引用取值,就取到了b对象头4bytes的值,这个值就是指向虚表的指针   
    	// 3.再强转成VFPTR*,因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    	// 4.虚表指针传递给PrintVTable进行打印虚表   
    	// 5.需要说明的是这个打印虚表的代码经常会崩溃,
    	//因为编译器有时对虚表的处理不干净,虚表最后面没有 放nullptr,导致越界,这是编译器的问题。
    	//我们只需要点目录栏的-生成-清理解决方案,再编译就好了。  
    	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    	PrintVTable(vTableb);
    	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTabled); 
    	return 0;
    }

    运行结果如下:

    6.2多继承中的虚函数表

    class Base1
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base1::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base1::Fun2()" << endl;
    	}
    private:
    	int b1;
    };
    class Base2
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base2::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base2::Fun2()" << endl;
    	}
    private:
    	int b2;
    };
    class Derive :public Base1,public Base2
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Derive::Fun1()" << endl;
    	}
    	virtual void Fun3()
    	{
    		cout << "Derive::Fun3()" << endl;
    	}
    private:
    	int d;
    };
    typedef void(*VFPTR) ();
    void PrintVTable(VFPTR vTable[])
    {  
    	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    	cout << " 虚表地址>" << vTable << endl;  
    	for (int i = 0; vTable[i] != nullptr; ++i)  
    	{       
    		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]); 
    		VFPTR f = vTable[i];    
    		f(); 
    	}   
    	cout << endl; 
    }
    int main()
    {
    	Derive d;
    	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTableb1);
    	VFPTR* vTabled2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
    	PrintVTable(vTabled2); 
    	return 0;
    }

    运行结果如下:

    可以发现:多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

     

     

     

     

     

     

     

     

     

    展开全文
  • 1.多态的概念: 1.1概念: 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生不同的状态 举个栗子:比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价...

    1.多态的概念:
    1.1概念:
    多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生不同的状态
    举个栗子:比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是优 先买票。

    2.多态的定义及实现
    2.1多态的构成条件
    多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Student继承了Person。 Person对象买票全价,Student对象买票半价。
    那么在继承中要构成多态还有两个条件:

    1. 必须通过基类的指针或者引用调用虚函数
    2. 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写
      在这里插入图片描述
      2.2 虚函数
      虚函数:即被virtual修饰的类成员函数称为虚函数。
    class Person 
    { 
    public:  
      virtual void BuyTicket()
       { 
       cout << "买票-全价" << endl;
        } 
       };
    

    2.3虚函数的重写
    虚函数的重写(覆盖):派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型,函数名字,参数列表完全相同),称子类的虚函数重写了基类的虚函数。

    class Person
    {
    public:
    	virtual void buyticket()
    	{
    		cout << "买票-全价" << endl;
    	}
    };
    
    class student:public Person
    {
    public:
    	virtual void buyticket()
    	{
    		cout << "买票-半价" << endl;
    	}
    	/*注意:在重写基类虚函数时,派生类的虚函数在不加virtual关键字时,
    	虽然也可以构成重写(因为继 承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),
    	但是该种写法不是很规范,不建议这样使用 */    
    	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
    };
    void Fun(Person& p)
    {
    	p.buyticket();
    }
    int main()
    {
    	Person ps;
    	student st;
    
    	Fun(ps);
    	Fun(st);
    	system("pause");
    	return 0;
    }
    

    函数重写的两个例外:
    1.协变(基类与派生类虚函数返回值类型不同)

    派生类重写基类虚函数时,与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引 用,派生类虚函数返回派生类对象的指针或者引用时,称为协变。

    class A{};
     class B : public A {};
     
    class Person
     {
      public: 
         virtual A* f() {return new A;
         } 
         };
     
    class Student : public Person
     {
      public:  
        virtual B* f() 
        {
        return new B;
        }
         };
    

    2.析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的 析构函数构成重写,虽然基类与派生类析构函数名字不同。虽然函数名不相同,看起来违背了重写的规 则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处 理成destructor

    class Person
    {
    public:
    	virtual ~Person()
    	{
    		cout << "~Person" << endl;
    	}
    };
    
    class student :public Person
    {
    public:
    	virtual ~student()
    	{
    		cout << "~student" << endl;
    	}
    };
    /*只有派生类student的析构函数重写了Person的析构函数。下面的
    delete对象调用析构函数,才能构成多态,才能保p1和p2指向的对象正确调用析构函数*/
    int main()
    {
    	Person* p1 = new Person;
    	Person* p2 = new student;
    
    	delete p1;
    	delete p2;
    
    	system("pause");
    	return 0;
    }
    

    2.4 C++11 override 和 final

    从上面可以看出,C++对函数重写的要求比较严格,但是有些情况下由于疏忽,可能会导致函数名字母次序 写反而无法构成重载,而这种错误在编译期间是不会报出的,只有在程序运行时没有得到预期结果才来 debug会得不偿失,因此:C++11提供了override和final两个关键字,可以帮助用户检测是否重写。

    2.override:检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译会报错。

    class Car
    {
    public:
    	virtual void Drive() final
    	{}
    };
    class Bens :public Car
    {
    public:
    	virtual void Drive()
    	{
    		cout << "Bens-舒适" << endl;
    	}
    };
    

    在这里插入图片描述
    2.override:检查派生类虚函数是否重写了某个基类某个虚函数,如果没有重写编译报错

    class Car
    {
    public:
    	virtual void Drive()
    	{}
    };
    class Bens :public Car
    {
    public:
    	virtual void Drive() override
    	{
    		cout << "Bens-舒适" << endl;
    	}
    };
    

    ** 2.5 重载 ,覆盖(重写),隐藏(重定义)的对比**
    在这里插入图片描述
    3. 抽象类
    3.1概念
    在虚函数的后面写上 =0 ,则这个函数为纯虚函数。**包含纯虚函数的类叫做抽象类(也叫接口类),抽象类 不能实例化出对象。**派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象。纯 虚函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承

    class Car
    {
    public:
    	virtual void Drive() = 0;
    };
    class Bens :public Car
    {
    	virtual void Drive()
    	{
    		cout << "Bens-舒适" << endl;
    	}
    };
    
    class BWM :public Car
    {
    public:
    	virtual void Drive()
    	{
    		cout << "BWM-操控" << endl;
    	}
    };
    void Test()
    {
    	Car* pBens = new Bens;
    	pBens->Drive();
    	Car* pBMW = new BWM;
    	 pBMW->Drive();
    }
    

    3.2 接口继承和实现继承

    普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的 继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。所 以如果不实现多态,不要把函数定义成虚函数。

    4. 多态的原理
    4,1 虚函数表
    // 这里常考一道笔试题:sizeof(Base)是多少?
    class Base
    {
    public:
    virtual void Func1()
    {
    cout << “Func1()” << endl;
    }

    private: int _b = 1;
    };

    通过观察测试我们发现b对象是8bytes,**除了_b成员,还多一个__vfptr放在对象的前面(注意有些平台可能会 放到对象的最后面,这个跟平台有关),对象中的这个指针我们叫做虚函数表指针(v代表virtual,f代表 function)。**一个含有虚函数的类中都至少都有一个虚函数表指针,因为虚函数的地址要被放到虚函数表中, 虚函数表也简称虚表,。那么派生类中这个表放了些什么呢?

    在这里插入图片描述

    // 针对上面的代码我们做出以下改造 
    //1.我们增加一个派生类Derive去继承Base 
    // 2.Derive中重写Func1
     // 3.Base再增加一个虚函数Func2和一个普通函数Func3 
    class Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Base::Fun1()" << endl;
    	}
    	virtual void Fun2()
    	{
    		cout << "Base::Fun2()" << endl;
    	}
    
    	void Fun3()
    	{
    		cout << "Fun3()" << endl;
    	}
    private :
    	int _b = 1;
    };
    
    class Derive :public Base
    {
    public:
    	virtual void Fun1()
    	{
    		cout << "Derive::Fun1()" << endl;
    	}
    private :
    	int _d = 2;
    };
    int main()
    {
    	Base b;
    	Derive d;
    
    	system("pause");
    	return 0;
    }
    
    1. 派生类对象d中也有一个虚表指针,d对象由两部分构成,一部分是父类继承下来的成员,虚表指针也就 是存在部分的另一部分是自己的成员。
    2. 基类b对象和派生类d对象虚表是不一样的,这里我们发现Func1完成了重写,所以d的虚表中存的是重 写的Derive::Func1,所以虚函数的重写也叫作覆盖,覆盖就是指虚表中虚函数的覆盖。重写是语法的 叫法,覆盖是原理层的叫法。
    3. 另外Func2继承下来后是虚函数,所以放进了虚表,Func3也继承下来了,但是不是虚函数,所以不会 放进虚表。
    4. 虚函数表本质是一个存虚函数指针的指针数组,这个数组最后面放了一个nullptr。
    5. 总结一下派生类的虚表生成:a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基 类中某个虚函数,用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在 派生类中的声明次序增加到派生类虚表的最后。
    6. 这里还有一个童鞋们很容易混淆的问题:虚函数存在哪的?虚表存在哪的? 答:虚函数存在虚表,虚表 存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指 针,不是虚函数,虚函数和普通函数一样的,都是存在代码段的,只是他的指针又存到了虚表中。另外 对象中存的不是虚表,存的是虚表指针。

    4.2 动态绑定与静态绑定

    1. 静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为,也称为静态多态,比如:函数 重载
    2. 动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用 具体的函数,也称为动态多态。

    5. 单继承和多继承关系的虚函数表
    5.1 单继承中的虚函数表

    class Base
    {
    public:
    	virtual void fun1()
    	{
    		cout << "Base::fun1" << endl;
    	}
    	virtual void fun2()
    	{
    		cout << "Base::fun2" << endl;
    	}
    private:
    	int a;
    };
    
    class Derive :public Base
    {
    	virtual void fun1()
    	{
    		cout << "Derive::fun1" << endl;
    	}
    	virtual void fun3()
    	{
    		cout << "Derive::fun3" << endl;
    	}
    	virtual void fun4()
    	{
    		cout << "Derive::fun4" << endl;
    	}
    private:
    	int b;
    };
    

    观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数, 也可以认为是他的一个小bug。

    展开全文
  • 多态的概念和意义

    2020-03-14 20:57:54
    在之前同名覆盖引发问题的那一...指向子类对象则调用子类中定义的重写函数,不要根据指针类型去调用,要根据指针指向的对象类型去调用,现在我们引入多态的概念实现多态,就需要用到virtual关键字对多态进行支持,被...
  • //2、动态多态:派生类虚函数实现运行时多态 一般C++中的多态只动态多态 //区别 //静态多态的函数地址是早绑定的 - 编译阶段确定函数地址 //动态多态的函数地址是晚绑定的 - 运行阶段确定函数地址 //动物类 class...
  • 多态的概念和作用

    2016-05-12 13:59:41
    多态是面向对象重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出多种形态。 编程其实就是一个将具体世界进行抽象化过程,多态就是抽象化一种体现,把一系列具体事物共同点抽象出来, ...
  • 多态多态的概述和实现多态成员的特点多态中的向上转型和向下转型多态的优点和缺点 多态的概述和实现 概念:多态是同一个行为具有不同表现形式或形态的能力,多态性是对象多种表现形式和体现。 多态的前提: 子父类...
  • 多态的概念

    2017-11-09 17:23:00
    前几天有人问我多态的概念,一时半会也没说清。 这种基本概念有时经常能问倒人,特此在这写一下,表述我对多态的理解。 多态就是明明是一个A物体却表现出B物体的行为。在代码中,多态的实现务必要继承,重写方法...
  • 实现前提:1.要有继承关系 2.要有方法覆盖 3.父类引用指向了子类实例1.继承关系好理解, 有 extends ,对类进行继承(假设 class A extends B{}即A是子类,B是父类,子类拥有父类所有成员)2.方法覆盖稍微不好...
  •    一、多态的基本概念    二、继承    三、多态的实现    四、多态存在的三个必要条件    五、重写    六、抽象类抽象方法    七、接口    八、向上转型实现多态    九、多态的优缺点...
  • 多态是面向对象重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出多种形态。 编程其实就是一个将具体世界进行抽象化过程,多态就是抽象化一种体现,把一系列具体事物共同点抽象出来, 再...
  • 在面向对象这里,多态是一个重要方法。它可以实现代码简化。 定义:多态是同一个行为具有多个不同表现形式或形态能力。 举个通俗例子:手机有WiFi功能模块,它可以连接不同WiFi。这就是多态,一句话就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,343
精华内容 1,337
关键字:

多态的概念和实现