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企服之家，中国第一个企服评测及商务社交产业平台。