基类与派生类,父类指针指向子类对象

先看一段代码:

 1 #include<iostream>
 2
 3 using namespace std;
 4
 5 class Base{
 6 public:
 7     Base() { cout<<"Base Creted"<<endl; }
 8     ~Base() { cout<<"Base Destroyed"<<endl; }
 9 };
10
11 class Derived: public Base {
12 public:
13     Derived() { cout<<"Derived Created"<<endl; }
14     ~Derived() { cout<<"Derived Destroyed"<<endl; }
15 };
16
17 int main()
18 {
19     Base *pB = new Derived();
20     delete pB;
21     pB = NULL;
22     return 0;
23 }

运行结果如下,情理之中,意料之内:

C++创建对象的时候先创建基类部分,然后创建派生部分。析构的时候要反过来了,先释放子类部分,然后在释放父类部分。但是这里只释放了父类部分,没有释放派生类的部分。为什么呢?

原因很明确:因为之类pB是基类指针,虽然指向的是派生类,只能调用自己的函数,我们是无法通过基类指针调用到子类的成员函数的(除非采用virtual,也就是迟绑定技术)。

虚函数

为了不造成内存泄漏,我们将上面代码改成:

1 class Base{
2 public:
3     Base() { cout<<"Base Creted"<<endl; }
4     virtual ~Base() { cout<<"Base Destroyed"<<endl; }   //virtual关键字很关键哦
5 };

运行结果正确了:

和之前版本相比,基类的析构函数多了一个 virtual 关键字。这样就使得父类类型的指针可以调用子类的成员函数。虚拟函数就是为了对“如果你以一个基础类指针指向一个衍生类对象,那么通过该指针,你只能访问基础类定义的成员函数”这条规则反其道而行之的设计。如果你打算将某个类作为基类,那么一定要定义一个虚析构函数。

虚函数通过动态绑定技术实现了C++的运行时的多态性。让我们可以通过基类的指针或者引用调用派生类的方法。C++中还有一个多态性是编译时的多态,通过模版实现。

《Effective C++》条款 07 p40:为多态基类声明virtual析构函数。

《Effective C++》条款 07 p44:

  • 带多态性质的base classes应该声明一个virtual析构函数。如果class带有任何virtual函数,它就应该拥有一个virtual析构函数
  • Classes的设计目的如果不是作为base classes 使用,或不是为了具备多态性,就不该声明virtual析构函数。

动态绑定的是怎么实现的?

1、为每个含义虚函数的类创建一个虚函数表VTable,存到常量区,依次存放虚函数的地址。对于每个派生类来说,如果没有重写基类的虚函数,那么派生类的虚函数表中的函数地址还是基类的那个虚函数地址。

2、为每个含有虚函数的对象创建一个指向VTable的指针VPtr,所以说同类对象的VPtr是一样的。

3、当基类指针指向派生类时,放生了强制转换,基类的指针指向了派生类的VPtr,这样当pBase->func()时,就可以调用派生类的func()了。

4、没有虚函数的类也就没有VTable表了,或者这个表为空。这样基类指针自然调用不到派生类的函数了。

思考:

为何要让父类指针指向派生类对象?

我觉得是为了实现C++的多态性。比如简单工厂模式,一开始我们并不知道需要生产哪种产品,也就不知道返回的是什么类型的产品,此时只能用基类指针去指向返回值。除此之外还没想到其他的使用场景。

原文地址:https://www.cnblogs.com/howo/p/8531449.html

时间: 2024-10-29 02:58:12

基类与派生类,父类指针指向子类对象的相关文章

用父类指针指向子类对象

class A {public:A() { printf("A \n"); }~A() { printf(" ~A \n"); } // 这里不管写不写virtual,删除B对象的时候,都会被执行.因为这个例子是B*指针指向B对象,不是A*指针指向B对象.}; class B : public A{public:B() { printf("B \n"); }~B() { printf("~B \n"); }}; int mai

当父类指针指向子类对象时的函数调用

class A { public: void FuncA() { printf( "FuncA called\n" ); } virtual void FuncB() { printf( "FuncB called\n" ); } }; class B : public A { public: void FuncA() { A::FuncA(); printf( "FuncAB called\n" ); } virtual void FuncB(

关于父类引用指向子类对象

例如: 有以下2个类 public class Father { public int age = 70; public static string name = "父亲"; } public class Son : Father { public int age = 30; public static string name = "儿子"; } Father f=new Son(); 这种用法叫做“父类引用指向子类对象,或者叫“父类指针指向子类对象”,指的是定义一

OC3-父类指针指向子类对象

// // Cat.h // OC3-父类指针指向子类对象 // // Created by qianfeng on 15/6/17. // Copyright (c) 2015年 qianfeng. All rights reserved. // #import "Animal.h" @interface Cat : Animal { float _height; } @property (assign,nonatomic)float height; @end // // Cat.m

父类指针指向子类实例:同名非虚函数

场景描述:如果父类指针指向子类的实例,并且调用的函数是一个子类和父类同名的函数,并且这个函数没有被定义为虚函数,肯定无法通过父类指针调用子类的接口.测试代码如下: class CFather{ public:      void Display()     {         cout<<"Father display"<<endl;     } }; class CSon:public CFather { public:      void Display()

java父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

【转】父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

理解父类引用指向子类对象

java多态,如何理解父类引用指向子类对象 要理解多态性,首先要知道什么是“向上转型”. 我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类.我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解. 但当我这样定义时:   Animal a = new Cat(); 这代表什么意思呢? 很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象.由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向C

java多态,如何理解父类引用指向子类对象

摘录 要理解多态性,首先要知道什么是“向上转型”. 我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类.我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解. 但当我这样定义时:   Animal a = new Cat(); 表示定义了一个Animal类型的引用,指向新建的Cat类型的对象.由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的. 那么这样做有什么意义呢?因为子类是对父类的一个改进