Polymorphism mechanism in c + +

Catalog

1. Background

2. Introduction to polymorphism

2-1 what is polymorphism

Classification of 2-2 polymorphism

2-3 conditions of dynamic polymorphism

2-4 static and dynamic coupling

2-5 realization principle of dynamic polymorphism

2-6 virtual destructor

2.7 thinking about virtual function

2.8 pure virtual function, abstract class, interface

Background introduction

Virtual function Rewriting: the subclass redefines the virtual function with the same return value, name and parameter in the parent class;

Non virtual function Rewriting: the subclass redefines the non virtual function with the same name and parameters in the parent class;

Assignment compatibility between parents and children: child objects can be used as parent objects (compatibility); the specific performance is as follows:

1. Subclass objects can be directly assigned to parent objects;

2. The subclass object can directly initialize the parent object;

3. The parent class pointer can directly point to the child class object;

4. The parent class reference can directly reference the child class object;

When assignment compatibility occurs, the subclass object degenerates into the parent object, which can only access the members defined in the parent class, and can directly access the members with the same name covered by the subclass;

 1 // In the assignment compatibility principle, the subclass object degenerates into the parent object, and the subclass is a special parent;
 2 #include <iostream>
 3 #include <string>
 4 
 5 using namespace std;
 6 
 7 class Parent
 8 {
 9 public:
10     int mi;
11 
12     void add(int i)
13     {
14         mi += i;
15     }
16     
17     void add(int a, int b)
18     {
19         mi += (a + b);
20     }
21 };
22 
23 class Child : public Parent
24 {
25 public:
26     int mi;
27     
28     void add(int x, int y, int z)
29     {
30         mi += (x + y + z);
31     }
32 };
33 
34 int main()
35 {
36     Parent p;
37     Child c;
38     
39     c.mi = 100;
40     p = c;             // p.mi = 0; Subclass objects degenerate to parent objects
41     Parent p1(c);   // p1.mi = 0; Ditto
42     Parent& rp = c;
43     Parent* pp = &c;
44     
45     rp.add(5);             
46     pp->add(10, 20);        
47     
48     cout << "p.mi: " << p.mi <<endl;                           // p.mi: 0; 
49     cout << "p1.mi: " << p1.mi <<endl;                       // p1.mi: 0;  
50     cout << "c.Parent::mi: " << c.Parent::mi <<endl;    // c.Parent::mi: 35
51     cout << "rp.mi: " << rp.mi <<endl;                        // rp.mi: 35
52     cout << "pp->mi: " << pp->mi <<endl;                 // pp->mi: 35
53     
54     return 0;
55 }

Assignment compatibility test

In the object-oriented inheritance relationship, we know that the subclass can have all the properties and behaviors in the parent class; however, sometimes the methods provided in the parent class cannot meet the existing needs, so we must rewrite the existing methods in the parent class in the subclass to meet the current needs. At this time, although we have implemented function rewriting (here is non virtual function rewriting), we can not expect the result in the type compatibility principle (we can not adjust to the corresponding rewriting function according to the actual object type pointed by the pointer / reference). Next, we use code to reproduce this scenario:

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:    
 9     void print()
10     {
11         cout << "I'm Parent." << endl;
12     }
13 };
14 
15 class Child : public Parent
16 {
17 public:    
18     void print()
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    // Expected to print: I'm Parent.
35     how_to_print(&c);   // I'm Parent    // Expected to print: I'm Child.
36     
37     return 0;
38 }

On the compatibility of non virtual function rewriting and assignment

Why does this happen? (in assignment compatibility, why can't a subclass override function be called when a parent class pointer / reference points to a subclass object?)

Problem analysis: during compilation, the compiler can only judge the object pointed to according to the type of pointer; according to the compatibility of assignment, the compiler thinks that the pointer of the parent class points to the object of the parent class; therefore, the compilation result can only call the function with the same name defined in the parent class.

When compiling this function, the compiler cannot know exactly what the pointer p points to. However, there is no reason for the compiler to report an error, so the compiler thinks that the safest way is to call the print function of the parent class. Because both the parent and the child must have the same print function.

To solve this problem, we need to use polymorphism in c + +. So how to realize polymorphism in c + +? Please see the following details:

Polymorphism introduction

1. What is polymorphism

In real life, polymorphism is a variety of forms of the same thing in different scenes.

In object-oriented, polymorphism refers to the behavior of dynamically calling the actual bound object function at runtime through the pointer or reference of the base class. The corresponding compile time binding function is called static binding.

2. Classification of polymorphism

Static polymorphism is completed by the compiler during compilation. The compiler will choose to call the appropriate function according to the type of arguments. If there is a suitable function, it will call, otherwise it will give a warning or error;

Dynamic polymorphism is a virtual function that determines which class to call according to the object pointed by the reference (pointer) of the base class when the program is running.

3. The conditions of dynamic polymorphism

According to previous problems, the compiler does not meet our expectations (because the compiler calls the function that is rewritten in the parent class according to the type of the parent class pointer). However, in the object-oriented polymorphism, we expect the behavior to determine how to call the rewrite function (virtual function) according to the actual object type.

1. When the parent class pointer (Reference) points to the parent class object, the virtual function defined in the parent class is called;

2. When the parent class pointer (Reference) points to the child class object, the virtual function defined in the child class is called;

The performance effect of this kind of polymorphic behavior is: the same call statement has many different performance forms in actual operation.

So in c + +, how to achieve this performance effect? (conditions for polymorphism)

2. There should be virtual function rewriting (the function declared by virtual is called virtual function)

3. There should be a parent class pointer (parent class reference) to the child class object

4. Static and dynamic binding

Static binding: specific function calls can be determined during program compilation, such as function overloading and non virtual function rewriting;

Dynamic binding: the specific function call can be determined only after the program is actually running, such as virtual function rewriting, switch statement and if statement;