1 //继承方式
  2 //语法：class 子类 ：继承方式  父类
  3 //继承方式 三种：
  4 //1.公共继承
  5 //2.保护继承
  6 //3.私有继承
  7 
  8 /*
  9 #include <iostream>
 10 #include <string>
 11 using namespace std;
 12 
 13 //继承方式
 14 //1.公共继承
 15 class Base1
 16 {
 17 public:
 18     int m_A;
 19 protected:
 20     int m_B;
 21 private:
 22     int m_C;
 23 
 24 };
 25 //1.公共继承
 26 class Son1 :public Base1
 27 {
 28 public:
 29     void func()
 30     {
 31         m_A = 10;   //父类中的公共权限成员 到子类中依然是 公共权限
 32 
 33         m_B = 20;  //父类中的公共权限成员，到子类依然是   保护权限
 34                    //类内可以访问   类外不可以访问
 35 
 36         //m_C = 30;  //父类中的私有全程成员，到子类中 访问不到    
 37     }
 38 };
 39 
 40 void test01()
 41 {
 42     Son1 s1;
 43     s1.m_A = 100;
 44     //s1.m_B = 100;  //类内可以访问   类外不可以访问
 45     
 46 
 47 }
 48 //保护继承
 49 class Base2
 50 {
 51     public:
 52         int m_A;
 53     protected:
 54         int m_B;
 55     private:
 56         int m_C;
 57 
 58 
 59 };
 60 
 61 class Son2 : protected Base2
 62 {
 63 public:
 64     void func2()
 65     {
 66         m_A = 100;  //父类中公共成员到 子类中变为保护权限
 67         m_B = 100;  //没有发生变化  还是私有成员
 68 
 69         //m_C = 100; //父类中私有成员 子类访问不到
 70     }
 71 };
 72 
 73 void test02()
 74 {
 75     Son2 s2;
 76     //s2.m_A = 1000;  //在Son2中已经变为了 保护权限  所以类外 访问不到
 77     //s2.m_B = 200;    //在Son2中已经变为了 保护权限  所以类外 访问不到
 78     //s2.m_C = 551;    //私有成员不可以访问
 79 
 80 
 81 }
 82 //私有继承
 83 class Base3
 84 {
 85     public:
 86         int m_A;
 87     protected:
 88         int m_B;
 89     private:
 90         int m_C;
 91 
 92 };
 93 class Son3 :private Base3
 94 {
 95 public:
 96     void func3()
 97     {
 98         m_A = 100;      //父类中公共成员到子类中变为 私有成员
 99 
100         m_B = 200;     //父类中保护成员到子类中变为  私有成员
101 
102         //m_C = 120;      //父类中的私有成员  子类不可以访问
103     }
104 
105 };
106 class GrandSon4 : public Son3
107 {
108 public:
109     void func4()
110     {
111         //m_A = 1000;  //到了 Son3中 m_A 变为私有，即使是 儿子也访问不到 
112         //m_B = 2000;  //到了 Son3中 m_A 变为私有，即使是 儿子也访问不到 
113     }
114 
115 };
116 void test03()
117 {
118     Son3 s3;
119 
120     //s3.m_A = 200;    //到Son3中 变为私有成员 访问不到
121     //s3.m_B = 100;    //到Son3中 变为私有成员 访问不到
122     //s3.m_C = 300;    //父类中的私有成员  子类不可以访问
123 
124 }
125 
126 int main()
127 {
128 
129 
130     system("pause");
131 
132     return 0;
133 
134 }
135 
136 */
137 
138 
139 
140 //继承中的对象模型
141 
142 
143 #include <iostream>
144 #include <string>
145 using namespace std;
146 
147 class Base
148 {
149 public:
150     int m_A;
151 protected:
152     int m_B;
153 private:
154     int m_C;
155 };
156 class Son :public Base
157 {
158 public:
159     int m_D;
160 };   
161 //利用开发人员命令提示工具查看对象模型
162 //跳转盘符 
163 //跳转文件路径 cd + 具体路径
164 //查看命名
165 //cl /d1 reportSingleClassLayout类名 文件名
166 void test01()
167 {
168     //16
169     //父类中所有非静态成员属性都会被 子类继承下去
170     //父类中私有成员属性 是被编译器给隐藏了 因此是访问不到 但是确实被继承下去了
171 
172     cout << "sizeof son = " << sizeof(Son) << endl;
173 }
174 
175 int main()
176 {
177 
178     test01();
179 
180 
181     system("pause");
182 
183     return 0;
184 
185 }