C++继承中的同名覆盖
2019-05-24 06:10:12来源:博客园 阅读 ()
1,父子间的冲突是由继承带来的,两个类之间存在了继承的关系,必然的会带来一 些问题,本文要讨论的是父子之间成员变量或成员函数的命名问题;
2,思考:
1,子类中是否可以定义父类中的同名成员?
1,可以,本文先编程解决这个问题;
2,这个问题就是同名覆盖问题;
2,如果可以,如何区分?如果不可以,为什么?
3,同名成员变量编程实验:
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Parent 7 { 8 public: 9 int mi; 10 }; 11 12 class Child : public Parent 13 { 14 public: 15 int mi; // 编译结果通过,子类可以定义父类里面的同名变量; 16 }; 17 18 int main() 19 { 20 Child c; 21 22 c.mi = 100; // mi 究竟是子类自定义的,还是从父类继承得到的? 23 24 return 0; 25 }
4,父子间的冲突(同名覆盖):
1,子类可以定义父类中的同名成员;
2,子类中的成员将隐藏父类中的同名成员;
1,编译器认为已经从父类中继承得到这个成员了,又自定义了一个同名成员,目的只有一个,就是你想要自己自定义的同名成员、而不想要从父类那里继承得到的同名成员,因此会产生同名覆盖现象;
3,父类中的同名成员依然存在于子类中;
1,隐藏、不是销毁;
4,通过作用域分辨符(::)访问父类中的同名成员;
5,访问父类中的同名成员方式:
1,Child c;
2,c.mi = 100; // 子类中的 mi;
3,c.Parent::mi = 1000; // 父类中的 mi;
6,同名成员变量深度分析编程实验:
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; // Parent() : &mi = 0xbfb43a08 Child() : &mi = 0xbfb43a0c 41 42 c.mi = 100; 43 44 c.Parent::mi = 1000; 45 46 cout << "&c.mi = " << &c.mi << endl; // &c.mi = 0xbfb43a0c,证明直接访问的是子类的 mi; 47 cout << "c.mi = " << c.mi << endl; // c.mi = 100; 48 49 cout << "&c.Parent::mi = " << &c.Parent::mi << endl; // &c.Parent::mi = 0xbfb43a08; 作用域分辨符访问父类 mi; 50 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1000; 51 52 return 0; 53 }
1,父类和子类可以产生同名覆盖冲突,但是通过作用域分辨符可以解决这个问 题;
7,再论重载:
1,类中的成员函数可以进行重载:
1,重载函数的本质为多个不同的函数;
2,函数名和参数列表是唯一的标识;
3,函数重载必须发生在同一个作用域中;
8,问题:
1,子类中定义的函数是否能重载父类中的同名函数?
1,将父子间的冲突问题上升到成员函数了;
9,父子间的函数重载编程实验:
1,继承父类成员函数,累加父类的同名成员;
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 28 int main() 29 { 30 Child c; 31 32 c.mi = 100; 33 34 c.Parent::mi = 1000; 35 36 cout << "c.mi = " << c.mi << endl; // c.mi = 100; 37 38 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1000; 39 40 c.add(1); // 继承自父类的成员函数;这个函数得到的 mi 不知道后面还要定义一个子类,它知道的 mi 只是父类中的,这个时候 mi 的作用域在父类中,所以给了父类中的 mi 做累加; 41 c.add(2, 3); // 继承自父类的成员函数; 42 43 cout << "c.mi = " << c.mi << endl; // c.mi = 100; 44 45 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1006;累加到父类中的 mi 了; 46 47 return 0; 48 }
2,函数的同名覆盖:
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 x, int y, int z) 28 { 29 mi += (x + y + z); 30 } 31 }; 32 33 int main() 34 { 35 Child c; 36 37 c.mi = 100; 38 39 c.Parent::mi = 1000; 40 41 cout << "c.mi = " << c.mi << endl; // c.mi = 100; 42 43 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1000; 44 45 // c.add(1); // 编译器显示没有匹配的函数调用 Child::add(int);同名成员函数覆盖,并没有重载,作用域不同; 46 // c.add(2, 3); // 编译器显示没有匹配的函数调用 Child::add(int, int);同名成员函数覆盖,并没有重载,作用域不同; 47 48 c.Parent::add(1); // 作用域分辨符解决同名成员函数覆盖问题; 49 c.Parent::add(2, 3); // 作用域分辨符解决同名成员函数覆盖问题;累加父类中的 mi 50 51 c.add(4, 5, 6); // 调用子类中的 add(),默认情况下访问的就是子类中的 mi,这个地方发生了同名覆盖; 52 53 cout << "c.mi = " << c.mi << endl; // c.mi = 115;默认访问的 mi 是子类中的 mi; 54 55 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1006;前两次累加的是父类中的 mi; 56 57 return 0; 58 }
10,父子间的冲突:
1,子类中的函数将隐藏父类的同名函数;
2,子类无法重载父类中的成员函数;
1,因为它们处于不同的作用域;
3,使用作用域分辨符访问父类中的同名函数;
1,类名加上作用域分辨符;
4,子类可以定义父类中完全相同的成员函数;
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; // c.mi = 100; 52 53 cout << "c.Parent::mi = " << c.Parent::mi << endl; // c.Parent::mi = 1000; 54 55 c.add(1); // 同名覆盖; 56 c.add(2, 3); // 同名覆盖; 57 c.add(4, 5, 6); // 函数重载; 58 59 cout << "c.mi = " << c.mi << endl; // c.mi = 121;函数同名覆盖和重载,都是默认访问的子类的 mi; 60 61 cout << "c.Parent::mi = " << c.Parent::mi << endl; // 父类中的函数被同名覆盖,未有访问父类中的 mi; 62 63 return 0; 64 }
11,小结:
1,子类可以定义父类中的同名成员;
2,子类中的成员将隐藏父类中的同名成员;
1,包括同名成员变量和同名成员函数;
2,重写的依据;
3,这就是同名覆盖;
3,子类和父类中的函数不能构成重载关系;
1,作用域不同;
4,子类可以定义父类中完全相同的成员函数;
1,作用域不同;
5,使用作用域分辨符访问父类中的同名成员;
1,父类名加上作用域分辨符;
原文链接:https://www.cnblogs.com/dishengAndziyu/p/10915115.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
上一篇:C++中的三种继承方式
下一篇:C++中多态的概念和意义
- C++ 转换函数搭配友元函数 2020-06-10
- C++ 自动转换和强制类型转换(用户自定义类类型) 2020-06-10
- C++ rand函数 2020-06-10
- C++ 友元函数 2020-06-10
- C++ 运算符重载 2020-06-10
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash