本篇要學習的內容和知識結構概覽
多型性
編譯時的多型性稱為靜態聯編. 當呼叫過載函式時, 在編譯期就確定下來呼叫哪個函式.
執行時的多型性稱為動態聯編. 在執行時才能確定呼叫哪個函式, 由虛擬函式來支援.
靜態聯編中的賦值相容性及名字支配規律
派生一個類的原因並非總是為了新增新的成員或成員函式, 有時是為了重新定義基類的成員函式.
#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++, 繼續挖掘語言的本質!