第47课 父子间的冲突

Posted 2021-01-03 wanmeishenghuo

思考：

同名成员变量：

图中的mi到底是子类的，还是从父类那里得到的？

父子间的冲突：

子类中的成员将隐藏父类中的同名成员，这叫同名覆盖。

是隐藏，是覆盖，而不是销毁，父类中的同名成员是依然存在的。我们通过作用域分辨符还是可以访问到的。

示例程序：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 namespace A
 7 {
 8     int g_i = 0;
 9 }
10 
11 namespace B
12 {
13     int g_i = 1;
14 }
15 
16 class Parent
17 {
18 public:
19     int mi;
20     
21     Parent()
22     {
23         cout << "Parent() : " << "&mi = " << &mi << endl;
24     }
25 };
26 
27 class Child : public Parent
28 {
29 public:
30     int mi;
31     
32     Child()
33     {
34         cout << "Child() : " << "&mi = " << &mi << endl;
35     }
36 };
37 
38 int main()
39 {
40     Child c;
41     
42     c.mi = 100;    
43     
44     c.Parent::mi = 1000;
45     
46     cout << "&c.mi = " << &c.mi << endl;
47     cout << "c.mi = " << c.mi << endl;
48     
49     cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
50     cout << "c.Parent::mi = " << c.Parent::mi << endl;
51     
52     return 0;
53 }

运行结果：

我们通过直接访问的方式访问的是子类中的mi。

39行确实访问到了父类中的mi，打印的地址跟父类中打印的一样。

两个mi虽然名字一样，但是处于不同的作用域当中。

 

再论重载：

问题：

子类中定义的函数能否重载父类中的同名函数？

父子间函数重载：

第40、41行的程序调用了add，现在调用的是从父类中继承来的add，而在这两个add中给mi累加，如16行那个add函数，这里的mi就是指的是父类中的mi，因为在父类中定义的函数只能看到父类中的mi，从打印结果也可以看出，只有父类中的mi被累加了，子类中mi依然是100。

我们在子类中也定义add函数：

这时我们可以看到45、46行报错了。

这是因为子类中的同名成员函数也会覆盖父类中的同名成员函数，不管它们参数是否一样。

子类中的函数和父类中的函数不构成重载，因为处于不同的作用域。

子类中定义了add函数，父类中所有叫add的函数全都被覆盖了。

只需要加上作用域分辨符就可以解决错误：

此时，45、46行就不会报错了。

运行结果如下：

第47行的程序累加的是子类中的mi。子类中的mi变为了115。

在子类中再重载两个add：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Parent
 7 {
 8 public:
 9     int mi;
10     
11     void add(int v)
12     {
13         mi += v;
14     }
15     
16     void add(int a, int b)
17     {
18         mi += (a + b);
19     }
20 };
21 
22 class Child : public Parent
23 {
24 public:
25     int mi;
26     
27     void add(int v)
28     {
29         mi += v;
30     }
31     
32     void add(int a, int b)
33     {
34         mi += (a + b);
35     }
36     
37     void add(int x, int y, int z)
38     {
39         mi += (x + y + z);
40     }
41 };
42 
43 int main()
44 {
45     Child c;
46     
47     c.mi = 100;    
48     
49     c.Parent::mi = 1000;
50     
51     cout << "c.mi = " << c.mi << endl;
52     
53     cout << "c.Parent::mi = " << c.Parent::mi << endl;
54     
55     c.add(1);
56     c.add(2, 3);
57     c.add(4, 5, 6);
58     
59     cout << "c.mi = " << c.mi << endl;
60     
61     cout << "c.Parent::mi = " << c.Parent::mi << endl;
62     
63     return 0;
64 }

 这时55、56行的程序就不会报错了，它们可以调用到子类中相应的函数。

 运行结果如下；

这时累加的mi都是子类中的了，最终值为121。

 

函数的父子间冲突：

小结：