Inheritance & Polymorphism | 继承与多态👀

Inheritance | 继承👀

classDiagram
Shape <-- Circle
    Circle : draw()
    Circle : erase()
Shape <-- Line
    Line : draw()
    Line : erase()
Shape <-- Square
    Square : draw()
    Square : erase()
Shape : draw()
Shape : erase()

• The ablitity to define the behavior or implementation of one class as a superset of another class ()
• Inheritance allows us to define one class as an extension of another
• Advantages of inheritance
  • Avoids code duplication
  • Code reuse
  • Easier maintenance
  • Extentibility

// Define an Employee class
class Employee {
public:
    Employee(const std::string& name, const std::string& ssn);
    const std::string& get_name() const;
    void print() const;
    void print(const std::string& msg) const;
protected:
    std::string m_name;
    std::string m_ssn;
};
Employee::Employee(const std::string& name, const std::string& ssn)
    : m_name(name), m_ssn(ssn) 
{
    // Initializer list sets up the values
}
// Employee member functions
inline const std::string& Employee::get_name() const 
{
    return m_name;
}
inline void Employee::print() const 
{
    std::cout << m_name << endl;
    std::cout << m_ssn << endl;
}
inline void Employee::print(const std::string& msg) const 
{
    std::cout << msg << endl;
    print();
}

class Manager : public Employee {
public:
    Manager(const std::string& name, const std::string& ssn, const std::string& title);
    const std::string& title_name() const;
    void std::string& get_title() const;
    void print() const;
protected:
    std::string m_title;
};
Manager::Manager(const std::string& name, const std::string& ssn, const std::string& title)
    : Employee(name, ssn), m_title(title) 
{
    // Initializer list sets up the values
}
// Manager member functions
inline const std::string& Manager::get_title() const 
{
    return m_title;
}
inline void Manager::print() const 
{
    Employee::print();
    std::cout << m_title << endl;
}

#include "Employee.h"
#include "Manager.h"
int main() {
    Employee e("John", "123-45-6789");
    Manager m("Mary", "987-65-4321", "VP");
    e.print();      // 正确
    m.print();      // 正确
    e.print("Employee");    // 正确
    m.print("Manager");     // 错误
    return 0;
}

• class B: public A 只有 public A 才是 OOP 语义上的继承
• class B: A 默认 class B: private A -> A 中的 public 和 protected 都变成 private
• class B: protected A -> A 中的 public 和 protected 都变成 protected

Polymorphism | 多态性👀

从继承引申出来的概念

• Public Inheritance should imply substitution
  • If B isa A (表达一种继承关系), you can use a B anywhere an A can be used
    • If B isa A, then everything that is true for A is also true for B
  • Be careful if the substition is not valid

Up-casting | 向上造型👀

• Is to regard an object of the derived class as an object of the base class
• It is to say: Students are human beings. You are students. So you are human beings.

graph LR
    A[HumanBeing] --> B[Students]

• Upcasting is the act of converting from a Derived reference or pointer to a Base class reference or pointer

graph LR
    A[Base] --> B[Derived]

Manager peter("Peter", "123-45-6789", "VP");
Employee* e = &peter;   // Upcasting
Employee& e = peter;    // Upcasting

#include <iostream>
using namespace std;
class A
{
public:
    int i;
    A(){ i = 10; cout << "A()" << i << endl; }
    void f() { cout << "A::f()" << endl; }
};
class B : public A
{
public:
    int i;
    B(){ i = 20; cout << "B()" << i << endl; }
    void f() { cout << "B::f()" << endl; }
};
int main()
{
    B b;
    A *p = &b;  // Upcasting
    b.f();
    p->f(); 
    cout << sizeof(*p) << endl;   
    int *pi = (int*)p;  // Downcasting
    cout << pi[0] << "," << pi[1] << endl;
    cout << p->i << endl;
    cout << b.i << endl;
}

A()10   # 先初始化父类
B()20   # 再初始化子类
B::f()  # 调用子类的函数
A::f()  # 调用父类的函数
4       # sizeof 发生在编译时期，此时 *p 是 A 类型，故为 4
10,20   # pi[0] 是 A 类型的 i，pi[1] 是 B 类型的 i
10      # p 是 A 类型，故 p->i 是 A 类型的 i
20      # b 是 B 类型，故 b.i 是 B 类型的 i

• Polymorphism is based on Upcast and Dynamic Binding

  • Upcast: take an object of the derived class as an object of the base one
  • Dynamic Binding (Binding -> which function to be called):
    • Static Binding: call the function as the code
    • Dynamic Binding: call the function of the object
  Example

  void render(Shape* p)
  {
      p->render();    // calls correct render function
  }   // for given Shape!
  void func()
  {
      Ellipse ell(10, 20);
      ell.render();   // static -- Ellipse::render()
  
      Circle cir(10);
      cir.render();   // static -- Circle::render()
  
      render(&ell);   // dynamic -- Ellipse::render()
      render(&cir);   // dynamic -- Circle::render()
  }
  

  • 在 C++ 中，当使用基类的引用或指针调用一个 virtual function 时，发生动态绑定
  • 上述代码中 Shape* p 被称为 polymorphic variable， 多态变量有两种类型
    • Static type: 声明类型 -> 即 Shape *
    • Dynamic type: 实际类型 -> 运行时刻才知道，即 Ellipse 或 Circle

  Quote

  C++中的动态类型与动态绑定、虚函数、运行时多态

Virtual functions👀

• Non-virtual functions
  • Compiler generates static, or direct call to stated type
  • Faster to execute
• Virtual functions
  • Can be transparently overriden in a derived class
  • Objects carry a pack of their virtual functions
  • Compiler checks pack and dynamically calls the right function
  • If compiler knows the functions at compile time, it will generate a static call

• Calls up the chain （如何在子类中调用父类函数）—— use Base::f()

  • No need to copy the old stuff!
  code

  void Derived::f()
  {
      Base::f();  // call to base class
  }
  

class Shape{
public:
    Shape();
    virtual ~Shape();
    virtual void render();
    void move(const XYPos&);
    virtual void resize();
protected:
    XYPos center;
};

class Ellipse: public Shape{
public:
    Ellipse (float majr, float minr);
    virtual void render();
protected:
    float major_axis;
    float minor_axis;
}

#include <iostream>
using namespace std;
class A
{
public:
    int i;
    A(){ i = 10; cout << "A()" << i << endl; }
    virtual void f() { cout << "A::f()" << endl; }
};
class B : public A
{
public:
    int i;
    B(){ i = 20; cout << "B()" << i << endl; }
    void f() { cout << "B::f()" << endl; }
};
int main()
{
    B b;
    A *p = &b;  // Upcasting

    long long **vp = (long long**)p;
    void (*pf)() = (void (*)())(*(*vp));
    cout << "------" << endl;
    pf();
}

A()10
B()20
------
B::f()

...
class A
{
public:
    int i;
    A(){ i = 10; cout << "A()" << i << endl; f(); }
    virtual void f() { cout << "A::f()" << endl; }
    void g() {this->f();}
};
...
int main()
{
    B b;
    A *p = &b;
    p->g();
}

A()10
A::f()
B()20
B::f()

• What happens if

  Ellipse elly(10F, 20F);
  Circle circ(30F);
  elly = circ;
  

  • Area of circ is sliced off (Only the part of circ that fits in elly gets copied)
  • 但 VPTR 并未改变 -> VPTR 构造出后就不会再改变 (除非暴力修改)

• Virtuals and reference arguments

  void func(Ellipse& elly)
  {
      elly.render();  // 动态绑定
  }
  ...
  Circle circ(10F);
  func(circ);
  

  • References act like pointers

• Virtual destructors

  • Make destructors virtual if they might be inherited
  codeExplanation

  Shape *p = new Ellipse(10.0F, 20.0F);
  ···
  delete p;   // 先析构（调用 destructor）再回收内存
  

  • delete p; 做的两件事情
    1. p->destructor(); -> 存在绑定问题, 若 p 的静态类型（Shape）的析构函数不是 virtual 则只在此处执行静态绑定，只执行 Shape 类的析构(但实际 p 指向的对象是 Ellipse, 此时 Ellipse 的析构未做)；但若是 virtual 编译器会在此处动态绑定，才会做有效的析构
    2. free
  • [Note] : 除非保证自己的类不会被继承，就将类的析构函数设置为 virtual -> 这个类就会有 VPTR 和 vtable
  • 那么其实 c++ 的每个类都应该有 vtable -> 通过 VPTR 和 vtable 的关系，我们建立了一种对象和类之间的关联 —— 可以实现 RTTI (Run Time Type Identification) | 但 c++ 暂不支持 RTTI
  • Want Ellipse::~Ellipse() to be called
    • Must declare Shape::~Shape() virtual
    • It will call Shape::~Shape() automatically
  • If Shape::~Shape is not virtual, only Shape::~Shape() will be invoked

Overriding👀

• overriding redefines the body of a virtual function

  • 指子类和父类有同名函数（函数名称相同、参数表也相同，且父类中声明 virtual）

  class Base
  {
  public:
      virtual void f();
  }
  class Derived : public Base
  {
  public:
      virtual void f();
      // override Base::f()
  }
  

  • 父类中有 virtual, 子类可以不加 virtual. 但习惯上还是加上 virtual，以免子类的继承者忘记加上 virtual 导致无法动态绑定 (貌似并不需要，测试了一下，不加 virtual 也可以动态绑定)

class Expr
{
public:
    virtual Expr* new_expr();
    virtual Expr& clone();
    virtual Expr  self();
};
class Binary : public Expr
{
public:
    virtual Binary* new_expr(); // OK
    virtual Binary& clone();    // OK
    virtual Binary  self();     // Error
};

Abstract base classes👀

• An abstract base class has pure virtual functions | 纯虚函数
  • Only interface defined
  • No function body given
• Abstract base classes cannot be instantiated | 不能被实例化
  • Must derive a new class/classes
  • Must supply definitions for all pure virtuals before class can be instantiated

class XYPos { ··· }; // x, y point
class Shape
{
public:
    Shape();
    virtual void draw() = 0;  // pure virtual fucntion
    void move(const XYPos&);
    virtual void resize();
protected:
    XYPos center;
};
class Circle : public Shape
{
public:
    virtual void draw();     // override
    ···
};
class Rectangle : public Shape
{
public:
    virtual void draw();     // override
    ···
};

• Why use
  • Modeling
  • Force correct behavior
  • Define interface without defining implementation
• When use
  • Not enough information is available
  • When designing for interf inheritance
• Protocol/Interface classes are abstract base classes with
  • All non-static member functions are pure virtual except for the destructor
  • Virtual destructor with empty body
  • No non-static member variables, inherited or otherwise
    • May contain static members
  • 即继承子类实现接口的规范的公开函数，但接口并不提供任何函数的实现

Multiple Inheritance👀

C++ 是唯一支持多继承的语言

class Employee
{
protected:
    string name;
    EmpID id;
}
class MTS : public Employee
{
protected:
    Degrees degree_info;
};
class Consultant : public MTS, public Temporary
{
    ···
};