C++中多态的概念和意义

Child c;
Parent* p = &c;
           
c.Parent::print();  // 从父类中继承；I‘m Parent.
c.print();  // 在子类中重写；I‘m Child.
           
p->print();  // 父类中定义；I‘m Parent.不是我们期望的版本，因为 p 指向了子类对象，期望调用子类版本

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     virtual void print()  // 这个函数可能被继承的子类重写，所以加上virtual 关键字来修饰它，称为虚函数，实现多态；
10     {
11         cout << "I‘m Parent." << endl;
12     }
13 };
14 
15 class Child : public Parent
16 {
17 public:
18     void print()  // 虽然没有写 virtual 关键字，但是由于继承的关系，它就是虚函数；一般工程中没必要在子类中写 virtual；
19     {
20         cout << "I‘m Child." << endl;
21     }
22 };
23 
24 void how_to_print(Parent* p)
25 {
26     p->print();     // 希望展现多态行为；
27 }
28 
29 int main()
30 {
31     Parent p;
32     Child c;
33     
34     how_to_print(&p);    // 期望打印: I‘m Parent.  实际打印：I‘m Parent.
35     how_to_print(&c);    // 期望打印: I‘m Child.  实际打印：I‘m Child.
36     
37     return 0;
38 }

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     virtual void func()
10     {
11         cout << "void func()" << endl;
12     }
13     
14     virtual void func(int i)
15     {
16         cout << "void func(int i) : " << i << endl;
17     }
18     
19     virtual void func(int i, int j)
20     {
21         cout << "void func(int i, int j) : " << "(" << i << ", " << j << ")" << endl;
22     }
23 };
24 
25 class Child : public Parent
26 {
27 public:
28     void func(int i, int j)
29     {
30         cout << "void func(int i, int j) : " << i + j << endl;
31     }
32     
33     void func(int i, int j, int k)  // 子类同名覆盖父类当中的函数，重载同一作用域当中的函数；
34     {
35         cout << "void func(int i, int j, int k) : " << i + j + k << endl;
36     }
37 };
38 
39 void run(Parent* p)
40 {
41     p->func(1, 2);     // 展现多态的特性，动态联编
42 }
43 
44 int main()
45 {
46     Parent p;
47     
48     p.func();         // 静态联编
49     p.func(1);        // 静态联编
50     p.func(1, 2);     // 静态联编
51     
52     cout << endl;
53     
54     Child c;
55     
56     c.func(1, 2);     // 静态联编
57     
58     cout << endl;
59     
60     run(&p);
61     run(&c);
62     
63     return 0;
64 }

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Boss
 7 {
 8 public:
 9     int fight()
10     {
11         int ret = 10;
12         
13         cout << "Boss::fight() : " << ret << endl;
14         
15         return ret;
16     }
17 };
18 
19 class Master
20 {
21 public:
22     virtual int eightSwordKill()
23     {
24         int ret = 8;
25         
26         cout << "Master::eightSwordKill() : " << ret << endl;
27         
28         return ret;
29     }
30 };
31 
32 class NewMaster : public Master
33 {
34 public:
35     int eightSwordKill()  // 重写八剑齐飞
36     {
37         int ret = Master::eightSwordKill() * 2;
38         
39         cout << "NewMaster::eightSwordKill() : " << ret << endl;
40         
41         return ret;
42     }
43 };
44 
45 void field_pk(Master* master, Boss* boss)
46 {
47     int k = master->eightSwordKill();  // 赋值兼容性加上函数重载，根据实际的对象调用函数；
48     int b = boss->fight();
49     
50     if( k < b )
51     {
52         cout << "Master is killed..." << endl;
53     }
54     else
55     {
56         cout << "Boss is killed..." << endl;
57     }
58 }
59 
60 int main()
61 {
62     Master master;
63     Boss boss;
64     
65     cout << "Master vs Boss" << endl;
66     
67     field_pk(&master, &boss);
68     
69     cout << "NewMaster vs Boss" << endl;
70     
71     NewMaster newMaster;
72     
73     field_pk(&newMaster, &boss);
74     
75     return 0;
76 }