一、继承的概念

1.面向对象中的继承指类之间的父子关系

2.子类拥有父类的所有成员变量和成员函数

3.子类就是一种特殊的父类

4.子类对象可以当作父类对象使用

5.子类可以拥有父类没有的方法和属性

继承小实例：

#include <iostream>
#include <stdio.h>
using namespace std;
class Parent
{
       private:
              int i;
       public:
              Parent()
              {
                     i= 100;  
              }
};
class Child:Parent  /* Child 继承 Parent */
{
};
 
int main(int argc, char **argv)
{
       ChildC;
       return0; 
}

6.C++中的访问级别与继承

继承时的访问级别设定会影响到成员的访问级别

class Child:Parent  /* Child 继承 Parent */
{
};
=======>
class Child:private Parent  /* Child 继承 Parent */
{
};

7.注意：

C++中class的继承默认为private继承

private继承的子类拥有父类的所有成员

private继承使得父类的所有成员在子类中变为private成员

8.C++中的访问级别与继承

public继承

父类成员在子类中保持原有访问级别

private继承

父类成员在子类中变为private成员

二、类成员的访问级别只有public和private是否足够？

1.类的protected成员

protected成员可以在子类中被访问，但不能在外界被访问

protected成员的访问权限介于public和private之间

举例：

#include <cstdlib>
#include <iostream>
#include <stdio.h>
 
using namespace std;
class Parent
{
       protected:
              int i;
       public:
              Parent()
              {
                     i= 100;  
              }
       void print(void)
       {
           std::cout<<"i = "<<i<<std::endl;   
       }    
};
class Child:public Parent
{
       private:
              int j;
       public:
       void print(void)
       {
           std::cout<<"i = "<<i<<std::endl;   
       }
};
 
int main(int argc, char **argv)
{
       ChildC;
       C.print();
       getchar();
       return0; 
}

那么，我们该如何选择使用继承方式呢？

1.类成员访问级别设置的原则

2.需要被外界访问的成员直接设置为public

3.只能在当前类中访问的成员设置为private

4.只能在当前类和子类中访问的成员设置为protected

private成员在子类中依然存在，但是却无法访问到。

继承与访问级别公式：

三、继承与访问的一个深度实例

#include <iostream>
using namespace std;
 
class A
{
       private:
              int a;
       protected:
              int b;
       public:
              int c;             
              A()
              {
                     a= 1;
                     b= 2;
                     c= 3;     
              }
              void setValue(int a, int b, int c)
              {
                     this->a= a;
                     this->b= b;
                     this->c= c;    
              }
};
class B:private A
{
       public:
              void print()
              {
                     //cout<<"a= "<<a<<endl;     /* a isprivate */
                     cout<<"b= "<<b<<endl;                           
                     cout<<"c= "<<c<<endl;      
              }    
};
class C:protected A
{
       public:
              void print()
              {
                     //cout<<"a= "<<a<<endl;        /* a is private */
                     cout<<"b= "<<b<<endl;                           
                     cout<<"c= "<<c<<endl;      
              }    
};
class D:public A
{
       public:
              void print()
              {
                     //cout<<"a= "<<a<<endl;           /* a is private */
                     cout<<"b= "<<b<<endl;                           
                     cout<<"c= "<<c<<endl;      
              }    
};
 
int main(int argc, char** argv)
{
       Aaa;
    Bbb;
    Ccc;
    Ddd;
   
   aa.c = 100;
   //bb.c = 100; /* 私有继承，所有成员都成为私有*/
    //cc.c = 100; /* 保护继承，不能类外引用*/
   dd.c = 100;    
      
}

在上面代码中，关键需要注意的地方都已经注释了，对照着上面的那张表应该很容易理解。

六、小结：

1.继承是一种类之间的关系，子类是一种特殊的父类

2.子类通过继承可以得到父类的所有成员

3.private成员可以被子类继承但不能被子类访问

4.protected成员只能在当前类和子类中被访问

5.不同的继承方式可能改变继承成员的访问属性

【C++第九课】---惊艳的继承