c++面向对象: public 继承, 虚方法, 动态绑定

た入场券 2022-04-22 11:06 108阅读 0赞

--------------------

title: ‘c++面向对象: public 继承, 虚方法, 动态绑定’  
date: 2018-11-04 13:00:34  
tags:

*  oop
 *  public inheritance
 *  virtual methods
 *  dynamic binding  
    categories: cpp  
    blog: [https://withas.me][https_withas.me]

--------------------

学了java中的面向对象后再来学习c++的面向对象, 对两者设计理念上的差异有不少的体会: c++更多地考虑了程序的运行效率(默认静态绑定, 没有垃圾回收等), 把很多繁琐的操作留给了使用者; 而java是贯彻了面向对象的思维, 有一种彻头彻尾的面向对象的感觉, 而把一些背后的机制向使用者隐藏了. 这篇blog主要记录c++中public继承相关的内容.

## Public Inheritance ##

c++中有public, protected, private三种继承方式, 其中public是最常用的.

public继承描述的是一种**is-a**的关系, derived-class是base-class的一个子集且一般是真子集. 比如从Student类可以派生出Cadre类, Cadre一定是Student, 而Student不一定是Cadre. 这种关系是单向的, 不具有对称性.

class Student { 
    private:
       int id;
       string name;
    public:
       int getId() const {  return id; }
    
       void setId(int id) {  Student::id = id; }
    
       const string &getName() const {  return name; }
    
       void setName(const string &name) {  Student::name = name; }
    };
    
    class Cadre : public Student { 
    private:
       string duty;
    public:
       const string &getDuty() const {  return duty; }
    
       void setDuty(const string &duty) {  Cadre::duty = duty; }
    };

Cadre由Student派生, 则Cadre直接继承了Student的所有public成员. Private成员也成为了derived-class的一部分, 但是只能通过base-class的public和protected方法访问. 例如Cadre从Student那里继承了name, 但是不能直接访问, 只能通过`Student::getName`访问.

class Cadre : public Student { 
    	...
    public:
        ...
        void showInfo() const { 
            cout << Student::getName() << endl;
            cout << Student::getId() << endl;
            cout << duty << endl;
        }
    };

### Constructos and Destructos ###

class Student { 
    private:
        int id;
        string name;
    public:
        Student(int id, const string &name) : id(id), name(name) { }
        ...
    };
    
    class Cadre : public Student { 
    private:
        string duty;
    public:
        Cadre(int id, const string &name, const string &duty) : Student(id, name), duty(duty) { }
    	...
    };

Derived-class不能直接直接访问继承自base-class的private成员, 所以不能在constructors里直接对它们初始化, 必须借助base-class的constructors. 并且base-class必须先于derived-class被构造. 如果要使用base-class的constructor有参数则必须在derived-class的constructor中以初始化参数列表的方式调用, 如上例. 如果不在derived-class的constructor中显式地调用base-class的constructor, 则默认使用base-class的不带参数的constructor(不存在则编译会产生错误).

Base-class会先于derived-class被构造. 析构的方向恰与之相反, derived-class的destructor先于base-class被执行.

### Is-a ###

前面提到过public继承是一种is-a的关系, 所以base-class的指针可以指向derived-class的对象, base-class的引用可以引用derived-class的对象.

Student *pc = new Cadre(1, "J", "monitor");
        Student &rc = *pc;

但是通过base-class的指针和引用只能使用base-class存在的属性, 如:

rc.getId();//ok
        rc.getDuty();//error

## Virtual Methods ##

### Redefine ###

有时候为了让derived-class有不同的功能我们可能需要重写base-class的方法.

class Student { 
    private:
        int id;
        string name;
    public:
        void showInfo() const { 
            cout << name << endl;
            cout << id << endl;
        }
    
    };
    
    class Cadre : public Student { 
    private:
        string duty;
    public:
        void showInfo() const { 
            cout << Student::getName() << endl;
            cout << Student::getId() << endl;
            cout << duty << endl;
        }
    };

这样我们对Student对象和Cadre的对象分别调用showInfo的时候就会输出不同的结果.

但是这样会产生一个问题:

Cadre *pc = new Cadre(1, "J", "monitor");
        Student &rc = *pc;
        pc->showInfo();
        cout << endl;
        rc.showInfo();
    /*output: J 1 monitor J 1*/

同一个Cadre对象, 用它自己的指针调用和用Student的引用调用时结果不一样. 查看输出结果可以知道用Student的引用调用的时候运行的是`Student::showInfo`, 而非在Cadre中重写的方法.

### Virtual methods ###

为了让base-class引用的derived-class可以调用derived-class重写的方法, 我们可以使用**virtual**.

class Student { 
    public:
        ...
        virtual void showInfo() const { 
            cout << name << "\t" << id;
        }
    };
    
    class Cadre : public Student { 
    public:
    	...
        virtual void showInfo() const { 
            Student::showInfo();//reusing code 
            cout << "\t" << duty;
        }
    };

再来看看输出结果:

Cadre *pc = new Cadre(1, "J", "monitor");
        Student &rc = *pc;//Student reference
        pc->showInfo();
        cout << endl;
        rc.showInfo();//invoke Cadre::showInfo() instead of Student::showInfo()
    /*output: J 1 monitor J 1 monitor */

如果不使用**virtual**, 调用的方法取决于引用或者指针的类型; 使用, 则由引用或者指向的对象本身决定, 也就是说可以使用base-class的引用或者指针调用在derived-class的重写的方法.

当base-class中的方法被标记为virtual时, derived-class中重写的方法也被自动标记为virtual. 不过一般为了方便阅读, 也将derived-class中重写的方法标记为virtual.

对于base-class中在derived-class被重写的方法一般都会被标记为virtual. 另外有derived-class的base-class的destructors最好被标记为virtual.

class A { 
    private:
        string *a;
    public:
        A() {  a = new string("Hello"); }
    
        ~A() {  delete a; }
    };
    
    class B : public A { 
    private:
        string *b;
    public:
        B() : A() {  b = new string("world"); }
    
        ~B() {  delete b; }
    };
    
    int main() { 
        A *pb = new B();
        delete pb;
    }

`delete pb`时会直接调用`A::~A()`, B中b的内存没有成功被释放. 所以为了内存的正确释放最好把base-class的destructor标记为virtual.

## Static and Dynamic Binding ##

绑定是指调用哪个具体的方法. 例如上面不加virtual关键词时`rc.showInfo`会调用引用类型的`showInfo`, 即`Student::showInfo;` 而加上virtual会调用`Cadre::showInfo`.

Cadre *pc = new Cadre(1, "J", "monitor");
        Student &rc = *pc;//Student reference
        rc.showInfo();

static binding是指在编译的时候就决定了调用的方法, 而dynamic binding是在程序运行过程中才能决定(因为对于一个base-class的指针可能指向base-class也可能指向derived-class). 这种dynamic binding的特性被称为多态.

c++默认的绑定方式是static binding. 对于dynamic binding对象内部会增加一个virtual function table (vtbl), 它负责记录这个对象应该调用的方法. 尽管dynamic binding看上去有更多的好处, 然而c++默认的绑定方式是static binding, 这样程序的运行效率更高. 与之对比, java中没有virtual function, 它默认的就是动态绑定.

dynamic binding产生的多态有什么好处呢? 看下面这个例子:

class Class { 
    private:
        vector<Student *> students;
    public:
        void addStudent(Student *student) { 
            students.push_back(student);
        }
    
        void listStudent() { 
            for (auto &s: students) { 
                s->showInfo();
                cout << endl;
            }
        }
    };
    //
    Class cla;
    Student a = Student(1, "Y");
    Cadre b = Cadre(2, "Z", "monitor");
    Student c = Student(3, "W");
    cla.addStudent(&a);
    cla.addStudent(&b);
    cla.addStudent(&c);
    cla.listStudent();
    /*output Y 1 Z 2 monitor W 3 */

在Class中我们全都储存的是Student的指针, 在打印Student List的时候就可以根据指向的具体对象输出相应的信息.

## Code ##

完整演示代码:

#include <iostream>
    #include <vector>
    
    using namespace std;
    
    class Student { 
    private:
        int id;
        string name;
    public:
        Student(int id, const string &name) : id(id), name(name) { }
    
        int getId() const {  return id; }
    
        void setId(int id) {  Student::id = id; }
    
        const string &getName() const {  return name; }
    
        void setName(const string &name) {  Student::name = name; }
    
        virtual void showInfo() const { 
            cout << name << "\t" << id;
        }
    
        virtual ~Student() { }
    };
    
    class Cadre : public Student { 
    private:
        string duty;
    public:
        Cadre(int id, const string &name, const string &duty) : duty(duty), Student(id, name) { }
    
        const string &getDuty() const {  return duty; }
    
        void setDuty(const string &duty) {  Cadre::duty = duty; }
    
        virtual void showInfo() const { 
            Student::showInfo();
            cout << "\t" << duty;
        }
    
    };
    
    class Class { 
    private:
        vector<Student *> students;
    public:
        void addStudent(Student *student) { 
            students.push_back(student);
        }
    
        void listStudent() { 
            for (auto &s: students) { 
                s->showInfo();
                cout << endl;
            }
        }
    };
    
    int main() { 
        Cadre *pc = new Cadre(1, "J", "monitor");
        Student &rc = *pc;
        pc->showInfo();
        cout << endl;
        rc.showInfo();
        delete pc;
        cout << endl;
        Class cla;
        Student a = Student(1, "Y");
        Cadre b = Cadre(2, "Z", "monitor");
        Student c = Student(3, "W");
        cla.addStudent(&a);
        cla.addStudent(&b);
        cla.addStudent(&c);
        cla.listStudent();
        return 0;
    }

--------------------

懒惰的我终于又开始更新了.

[https_withas.me]: https://withas.me