IT评测·应用市场-qidao123.com

标题: C++ 继续 [打印本页]
作者: 美食家大橙子    时间: 2025-3-8 08:11
标题: C++ 继续
继续

继续基本语法

提要点:class 子类 : 继续方式 父类
  1. //继承语法: class 自己定义的类(子类):继承方式 父类
  2. #include<iostream>
  3. using namespace std;
  4. class Person
  5. {
  6. public:
  7.     void body()
  8.     {
  9.         cout<<"Hello pretty girl"<<"\n";
  10.     }
  11.     void age1()
  12.     {
  13.         cout<<"19"<<"\n";
  14.     }
  15. };
  16. class Alaso_shuang : public Person
  17. {
  18. public:
  19.     void voice()
  20.     {
  21.         cout<<"interesting to listen"<<"\n";
  22.     }
  23. };
  24. void test()
  25. {
  26.     Alaso_shuang Alaso;
  27.     Alaso.age1();
  28.     Alaso.body();
  29.     Alaso.voice();
  30. }
  31. int main()
  32. {
  33.     test();
  34.     return 0;
  35. }
复制代码

继续方式

提要点:
1.继续方式分为:公共继续(public)、掩护继续(protected)、私有继续(private)
2.当子类以共有继续 继续父类时,父类全部的对象(除了private)都是可以以共有继续形式访问
2.当子类以 掩护继续 继续父类时,子类全部继续对象均以掩护继续的形式出现，并且表里不能访问
3.当子类以 私有继续 继续父类时，子类全部继续对象均以私有继续的形式出现
  1. #include<iostream>
  2. using namespace std;
  3. class F
  4. {
  5. public:
  6.     int a;
  7. protected:
  8.     int b;
  9. private:
  10.     int c;
  11. };
  12. class F1
  13. {
  14. public:
  15.     int a;
  16. protected:
  17.     int b;
  18. private:
  19.     int c;
  20. };
  21. class F2
  22. {
  23. public:
  24.     int a;
  25. protected:
  26.     int b;
  27. private:
  28.     int c;
  29. };
  30. class son : public F
  31. {
  32. public:
  33.     void f()
  34.     {
  35.         a = 10;//父类中公共权限成员拿到手了
  36.     }
  37. protected:
  38.     void f1()
  39.     {
  40.         b = 20;
  41.     }
  42. // private:
  43. //     void f3()
  44. //     {
  45. //         c = 1;//报错啦
  46. //     }
  47. };
  49. class son1 : protected F1
  50. {
  51. protected:
  52.     void f1()
  53.     {
  54.         a = 10;
  55.         b = 40;
  56.         //c = 90;//继续报错,说明父类隐私不允许访问
  57.     }
  58. };
  59. class son2 : private F2
  60. {
  61. private:
  62.     void f5()
  63.     {
  64.         a = 100;
  65.         b = 300;
  66.     }
  67. };
  68. void test01()
  69. {
  70.     son1 s;
  71. }
  72. int main()
  73. {
  74.     test01();
  75.     return 0;
  76. }
复制代码

继续中对象模型

提要点:父类中全部对象均会被子类继续
  1. #include<iostream>
  2. using namespace std;
  3. class f
  4. {
  5. public:
  6.     int a;
  7. protected:
  8.     int b;
  9. private:
  10.     int c;
  11. };
  12. class son1:public f
  13. {
  14.     int a;
  15. };
  16. void solve()
  17. {
  18.     son1 s;
  19.     cout<<"sizeof's value : "<< sizeof(s);
  20. }
  21. int main()
  22. {
  23.     solve();
  24.     //答案是16,说明父类所有的成员都继承在了子类身上
  25.     return 0;
  26. }
复制代码

继续同名成员处理方式

提要点:
1.访问子类同名成员(直接访问即可)
2.访问父类同名成员(需要加作用域)
  1. #include<iostream>
  2. using namespace std;
  3. class F
  4. {
  5. public:
  6.     F()
  7.     {
  8.         a = 10000;
  9.     }
  10. public:
  11.     int a;
  12. };
  13. class son1 : public F
  14. {
  16. public:
  17.     son1()
  18.     {
  19.         a = 2000000;
  20.     }
  21.    
  22. public:
  23.     int a;
  24. };
  25. void solve()
  26. {
  27.     son1 s;
  28.     cout<<s.a<<"\n";
  29.     F f;
  30.     cout<<f.F::a<<"\n";//父类添加作用域
  31. }
  32. int main()
  33. {
  34.     solve();
  35.     return 0;
  36. }
复制代码

多继续

提要点:语法:子类:public 父类1,public 父类2
(不建议利用该格式，会引来麻烦)
  1. #include<iostream>
  2. using namespace std;
  3. class F1
  4. {
  5. public:
  6.     F1()
  7.     {
  8.         m_A = 100000;
  9.     }
  10. public:
  11.     int m_A;
  12. };
  14. class F2
  15. {
  16. public:
  17.     F2()
  18.     {
  19.         m_B = 200000;
  20.     }
  21.    
  22. public:
  23.     int m_B;
  24. };
  25. class children : public F1,public F2//继承两个父类
  26. {
  27. public:
  28.     int c_M;
  29.     int d_M;
  30. };
  31. void test()
  32. {
  33.     children C;
  34.     cout<<sizeof(C)<<"\n";
  35.     cout<<C.m_A<<"\n";
  36.     cout<<C.m_B<<"\n";
  37.     //若是父类成员名称相同，就按照继承同名成员方式处理,直接加作用域即可
  38. }
  39. int main()
  40. {
  41.     test();
  42.     return 0;
  43. }
复制代码

菱形继续

提要点:
1.菱形继续会导致所指对象的属性不明白，还会浪费空间
2.办理菱形继续的办法:虚继续,在父类前加一个 virtual即可
一样寻常我们不会写菱形继续的形式，在此也不做代码解释了哈哈哈哈哈

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4