<<從0到1學C++>> 第7篇 多態性和虛函數

本篇要學習的內容和知識結構概覽

多態性

編譯時的多態性稱爲靜態聯編. 當調用重載函數時, 在編譯期就肯定下來調用哪一個函數.

運行時的多態性稱爲動態聯編. 在運行時才能肯定調用哪一個函數, 由虛函數來支持.

靜態聯編中的賦值兼容性及名字支配規律

派生一個類的緣由並不是老是爲了添加新的成員或成員函數, 有時是爲了從新定義基類的成員函數.

#define PI 3.14159

class Point {
    double x;
    double y;
    
    public:
    Point(double a, double b) {
        x = a;
        y = b;
    }
    double area() {
        return 0;
    }
};

class Circle: public Point {
    double radius;
    
    public:
    Circle(double a, double b, double r):Point(a, b) {
        radius = r;
    }
    
    double area() {
        return PI * radius * radius;
    }
};

int main() {
    Point a(1.5, 6.7);
    Circle c(1.5, 6.7, 2.5);
    
    cout << a.area() << endl; // 調用對象a的成員函數area()
    cout << c.area() << endl; // 調用對象c的成員函數area()
    
    Point * p = &c; // 對象c的地址爲指向Point類型指針賦值
    cout << p -> area() << endl; // 調用Point類的成員函數area()
    
    Point & rc = c; // 對象c初始化Point類型的引用
    cout << rc.area() << endl; // 調用Point類的成員函數area()
}複製代碼

在派生類有同名函數的狀況下

Point * pPoint; // 聲明的基類指針只能指向基類
複製代碼

Circle * pCircle // 聲明的派生類指針只能指向派生類複製代碼

若是派生類沒有基類的同名函數, 派生類的指針才根據繼承原則調用基類的函數

虛函數

一旦定義了虛函數, 該基類的派生類中的同名函數也自動成爲虛函數.

虛函數的定義

用關鍵字virtual來聲明一個虛函數, 虛函數只能是類中的一個成員函數, 不能是靜態成員.

像這樣

class Point {
    double x;
    double y;
    
    public:
    Point(double a, double b) {
        x = a;
        y = b;
    }
    
    // 用virtual關鍵字來定義一個虛函數
    virtual double area() {
        return 0;
    }
};

class Circle: public Point {
    double radius;
    
    public:
    Circle(double a, double b, double r):Point(a, b) {
        radius = r;
    }
    
    // 基類中area()函數爲虛函數, 派生類中的同名函數也自動成爲虛函數
    double area() {
        return PI * radius * radius;
    }
};
複製代碼

虛函數實現多態性的條件

關鍵字virtual告訴編譯器調用虛函數進行動態聯編.

使用虛函數不必定產生多態性, 也不必定使用動態聯編.

在調用中對虛函數使用成員名限定, 能夠強制編譯器對該函數使用靜態聯編.

產生運行多態性, 也就是動態聯編有3個前提

• 類之間的繼承關係知足賦值兼容性規則
• 改寫了同名虛函數
• 根據賦值兼容性規則使用指針(或引用)

像這樣

class Point {
    double x;
    double y;
    
    public:
    Point(double a, double b) {
        x = a;
        y = b;
    }
    
    // 用virtual關鍵字來定義一個虛函數
    virtual double area() {
        return 0;
    }
};

class Circle: public Point {
    double radius;
    
    public:
    Circle(double a, double b, double r):Point(a, b) {
        radius = r;
    }
    
    // 基類中area()函數爲虛函數, 派生類中的同名函數也自動成爲虛函數
    double area() {
        return PI * radius * radius;
    }
};

void display(Point * p) {
    cout << p -> area() << endl;
}

void display(Point & a) {
    cout << a.area() << endl;
}

int main() {
    Point a(1.5, 6.7);
    Circle c(1.5, 6.7, 2.5);
    Point * p = &c; // 對象c的地址爲指向Point類型指針賦值
    Point & rc = c; // 對象c初始化Point類型的引用
    
    display(a); // 調用對象a的成員函數area()
    display(p); // 根據運行時的多態性, p指向的c對象, 因此實際調用c對象的成員函數area()
    display(rc); // 根據運行時的多態性, rc是對c對象的引用, 因此實際調用c對象的成員函數area()
    /** 輸出結果
     0
     19.6349
     19.6349
     */
}
複製代碼

純虛函數與抽象類

在基類中不給虛函數一個有意義的定義, 能夠說明爲純虛函數, 將定義留給派生類去作

像這樣

class 類名 {
    public:
    virtual 函數類型 函數名(參數列表) = 0;
};
複製代碼

抽象類: 包含有純虛函數的類稱爲抽象類. 一個抽象類至少有一個純虛函數, 一個抽象類只能做爲基類來派生新類, 不能說明抽象類的對象.

class Point {
    double x;
    double y;
    
    public:
    Point(double a, double b) {
        x = a;
        y = b;
    }
    
    // 用virtual關鍵字來定義一個虛函數
    virtual double area() = 0;
};

int main() {
	// Point a(1.5, 6.7); // Point爲抽象類, 不能實例化一個對象 error Variable type 'Point' is an abstract class
	Point * p; // Point爲抽象類, 能夠聲明一個指向抽象類對象的指針
}複製代碼

注意

空虛函數定義 virtual void area() {}

純虛函數定義 virtual void area() = 0;

純虛函數的派生類還是抽象類. 若是派生類中給出了基類全部純虛函數的實現, 則該派生類再也不是抽象類

類族

若是經過同一個基類派生一系列的類, 則將這些類總稱爲類族.

像這樣

#define PI 3.14159

// 抽象類 有一個純虛函數 area()
class Shape {
    public:
    virtual double area() = 0;
};

// 正方形 有一個連長數據成員
class Square: public Shape {
    protected:
    double h;
    
    public:
    Square(double a) {
        h = a;
    }
    double area() {
        return h * h;
    }
};

// 圓
class Circle: public Square {
    public:
    Circle(double a):Square(a) {
        
    }
    double area() {
        return h * h * PI;
    }
};

// 三角形
class Triangle: public Square {
    protected:
    double w;
    
    public:
    Triangle(double a, double b):Square(a) {
        w = b;
    }
    double area() {
        return w * h * 0.5;
    }
};

// 矩形
class Rect: public Triangle {
    public:
    Rect(double a, double b):Triangle(a, b) {
        
    }
    double area() {
        return w * h;
    }
};

int main() {
    
    Shape * s[5];
    s[0] = new Square(4);
    s[1] = new Circle(10);
    s[2] = new Rect(3, 6);
    s[3] = new Triangle(3, 6);
    s[4] = new Square(6);
    for (int i = 0; i < 5; i++) {
        // 由於虛函數支持動態聯編, 因此在運行時才肯定每一個元素的類型, 調用各自的成員函數
        cout << "s[" << i << "] = " << s[i] -> area() << endl;
    }
}
複製代碼

多重繼承與虛函數

多重繼承能夠被視爲多個單一繼承的組合.

// 基類
class A {
    public:
    virtual void func() {
        cout << "call A" << endl;
    }
};

// 基類
class B {
    public:
    virtual void func() {
        cout << "call B" << endl;
    }
};

// 多重繼承
class C: public A, public B {
    public:
    void func() {
        cout << "call C" << endl;
    }
};

int main() {
    A * pa;
    B * pb;
    C * pc, c;
    
    pa = &c;
    pb = &c;
    pc = &c;
    pa -> func(); // 動態聯編, pa指向派生類對象c, 調用對象c的成員函數C::func();
    pb -> func(); // 動態聯編, pb指向派生類對象c, 調用對象c的成員函數C::func();
    pc -> func(); // pc既是指向C類對象的指針, 又是指向的C類對象, 調用對象c的成員函數C::func();
}複製代碼

總結

C++有兩種多態性, 一種是編譯時多態性, 也叫靜態聯編; 另外一種是運行時多態性, 也叫動態聯編. 這大大提升了咱們解決問題的豐富性. 可能也是C++長久不衰的魅力所在吧! 我會繼續深刻學習C++, 繼續挖掘語言的本質!

本系列文章會持續更新! 你們踊躍的留下本身的腳印吧!

👣👣👣👣👣👣👣👣