继承的概念

继承的机制为,允许在以该类为基础上对类进行扩展,增加功能;

通常原来也就是被用来继承的类称之为父类或者是基类,而通过继承产生的新类被称为子类或者是派生类;

派生类将会以继承规则或者是基类原有的访问限定符为限定对属性进行一定的调整;

class Person
{//基类/父类
  protected:
    string _name = "LiHua";
    int _age = 18;
};

class Student : public Person //语法
{//派生类/子类
  void Func()
  {
    cout<<"study now"<<endl;
  }
};

从该代码可以大概了解继承的概念;

即子类在继承父类属性的基础上再进行拓展;

由上述代码可以得知Sudent类为Person类的派生类,Student类中的属性除了Func()函数以外也包含了Person 的属性;

继承体现了在多个类中对于同一属性的复用;

---

继承方式与访问限定符

在对类与对象的学习中,提到了访问限定符;

• public 公有
• private 私有
• protected 保护

访问限定符也就是在不同使用场景中,类中的成员将会根据访问限定符的修饰产生一定的限制;

类中的public公有成员类内外都可被访问;

类中的private私有成员与protected保护成员类内可以访问,类外不能被访问;

而在继承方式中也同样有三种方式,也为:

• public
• private
• protected

继承是所谓的派生类继承基类的各个属性;

而派生类中基类的成员将会根据访问限定符与继承方式的不同而做出一定的变化;

继承方式\访问限定符	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

从上表中可以看出,基类的private成员无论是用什么方式继承,最终在派生类中都处于一种不可见的状态;

同时可以推断出,派生类中成员的权限一般为继承方式权限与基类成员权限中较小的那个( public > protected > private );

从该处可以进行一个分类,分为基类的private成员与其他;

class Person
{
  public:
  protected:
    string _name = "LiHua";
    int _age = 18;
  private:
    int _todel = 10;
};

class Student : public Person 
{
  void Func()
  {
    cout<<Person::_todel<<endl; // errory : _todel为Person中的私有成员,在派生类中不可见也不可被调用
  }
};

当然对于继承方式来说也可以省略:

• class Student : Person class派生类的默认继承方法为private;
• struct Techer : Person struct派生类的默认继承方式为public;

但是一般在写的过程中尽量不要省略;

---

基类和派生类对象赋值转换

在一般的变量当中,两个相同变量可以相互进行赋值;

int main()
{
    int a = 10,b = 0;
    b = a;
    return 0;
}

对于类型不同的两个内置类型变量而言也可以相互进行赋值;

int main()
{
    double a = 12.2;
    int b = 10;
    b = a;//发生隐式类型转换
    const int &c = a;//引用具有常性的数据应用const修饰
}

首先我们知道,对于赋值而言并不是直接将数据本身进行赋值,在赋值的过程中将会生成一个临时对象,最终这个临时对象会赋值给这个需要赋值的变量当中;

但在继承当中,派生类对象是否可以赋值给其基类的基类对象?

事实上是可以的,由于派生类对象归根结底属于基类对象的延申\拓展,所以它具备了对应基类的所有属性;

在赋值过程中将会取出对应的基类对象中的属性,将其属性赋值给基类对象;

/*
class Person{};
class Student:public Person{};
*/
int main()
{
    Person per;
    Student stu;
    
    per = stu;//切片\切割;
    
    Person &per_1 = stu;
    //该处的引用并不需要进行const修饰,中途不产生临时对象;
    //同时该处在进行引用时,per_1 将为stu中Person对应成员的别名;
    
    Person *ptrp = &stu;//取出Person对应stu中成员的地址;
    
    return 0;
}

对于基类和派生类对象赋值转换也有另外一种说法切片\切割;

派生类对象可以赋值给基类对象,但是基类对象不能赋值给派生类对象;

---

继承中的作用域

存在两个类分别为A与B,其中B是A的派生类;

class A
{
  public:
    int a = 9;
    int b = 10;
};

class B : public A
{
  public:
    int c = 500;
};

void test_2()
{
  B b1;
  cout<<b1.a<<" "<<b1.b<<endl;
}

在该处对test_2()函数进行调用时结果为{ 9 , 10 };

结果是在默认情况下由于派生类为以基类为基础的拓展/延申,所以具有基类的属性,可以直接调用对应的成员;

但在实际的定义当中,派生类与基类都有独立的域,所以说在自己所在的域内进行操作将不会影响另一个类(基类/派生类);

这也包括在对应的类中的同名成员;

---

隐藏

为什么在基类与派生类中可以存在同名的成员?

class A
{
  public:
    int a = 9;
    int b = 10;
};

class B : public A
{
  public:
    int a = 100;
    int b = 200;
};

void test_2()
{
  B b1;
  cout<<b1.a<<" "<<b1.b<<endl;
}

运行上面这段代码的结果将是[ 100 , 200 ];

原因是因为在默认情况下(基类与派生类中不存在同名成员时)若是需要调用的成员为基类成员时可以直接进行调用;

但是在这里基类和派生类都有同名的成员a,b,由于基类与派生类都有各自独立的域,所以在此处若是想调用对应成员的时候将首先调用派生类自己域中的对应成员;

当然基类的成员并不是不能被调用,只是在调用的时候应该使用域作用限定符::指定域;

cout<<b1.A::a<<" "<<b1.A::b<<endl;

通常我们称作:

• 当基类与派生类中存在同名成员时,将构成隐藏\重定义,在该种情况下若从派生类中调用该同名成员时将会优先调用派生类自己域中的对应成员,若是想调用基类中的同名成员则需要使用域作用限定符::进行指定域;

当然,构成隐藏\重定义的条件不仅仅是只有成员变量:

• 当基类与派生类中存在同名成员函数时(只要是同名,不需要考虑参数或返回值),即可构成隐藏\重定义;

在使用过程中尽量不要定义同名

---

派生类的默认成员函数

构造函数

在类中,默认成员函数分别为:

构造函数

拷贝构造函数

析构函数

赋值运算符重载

取地址重载

const取地址重载

以该段代码为例:

class Parent
{
  public:
    Parent()
  {
    cout<<"Parent()"<<endl;
  }
    ~Parent(){
      cout<<"~Parent()"<<endl;
    }
  protected:
    string _name;
    int _age;
};

class Child : public Parent
{};
void test(){
	Child ch;    
}

若是调用test()函数的结果为:

该处实例化一个派生类对象,但是调用的确是基类的构造函数与析构函数;

说明在实例化一个派生类时,将会去自动调用它的基类的构造函数来初始化派生类中的基类,并在析构的过程中去调用它的基类的析构函数去清理掉派生类中的基类的数据;

在继承当中,基类与派生类当中都属于独立的域,所以在对派生类进行初始化时将会去调用该派生类的基类中的构造函数(析构函数);

假设需要显式调用其构造函数应该怎么进行调用?

class Parent //基类
{
  public:
    Parent(const char*name)
    :_name(name)
  {
    cout<<"Parent()"<<endl;
  }

    ~Parent(){
      cout<<"~Parent()"<<endl;
    }
  protected:
    string _name;
};

class Child : public Parent  //派生类
{
  public:

    Child(const char* name,size_t age)
      :	//_name(name) - error
       	//Parent::_name(name) - error
    	Parent(name)
      ,_age(age)
    {
      cout<<"Child()"<<endl;
    }
    
    ~Child(){
      cout<<"~Child()"<<endl;
    }
    
  protected:
    size_t _age;
};

void test(){
    Child chi("Lihua",18);
}

在基类和派生类的关系当中,派生类无法去初始化基类对应的参数,要对对应参数进行初始化时应该去调用它的构造函数;

当然若是基类存在默认构造函数(无参\全缺省)时可以不用显式调用基类的构造函数;

但若是基类不存在默认构造函数时,将必须在初始化列表当中调用基类的构造函数;

当然,在实例化一个派生类对象时,基类与派生类的构造函数与析构函数的调用顺序为:

• 基类的构造函数 -> 派生类的构造函数 -> 派生类的析构函数 -> 基类的析构函数

---

拷贝构造函数

存在基类与派生类,代码与上述相同,唯独不同的是在两个类中都存在拷贝构造函数:

class Parent //基类
{
  public:
    //构造 - 打印 "Parent()" 
	Parent(const Parent& par){
        cout<<"Parent(const Parent& par)"<<endl;
    }
    //析构 - 打印 "~Parent()"
  protected:
    string _name;
};

class Child : public Parent  //派生类
{
  public:
    //构造 - 打印 "Child()"
    Child(const Child& chi){
        cout<<"Child(const Child& chi))"<<endl;
    }
    //析构 - 打印 "~Child()"
  protected:
    size_t _age;
};

void test(){
    Child chi("Lihua",18);
    Child chi1(chi);
}

若是在该处调用test()函数的结果为:

若是在派生类中存在拷贝构造函数,且派生类的拷贝构造函数内并没有调用基类的拷贝构造时时,派生类的拷贝构造函数并不会去主动调用基类的拷贝构造函数;

所以在派生类中的拷贝构造函数应该主动去调用基类的拷贝构造函数(同样在初始化列表当中);

Child(const Child& chi)
:Parent(chi)
{
	cout<<"Child(const Child& chi))"<<endl;
}

在这里基类的拷贝构造参数类型为const Parent&,而传过去的类型为const Child&,在这里将会发生切片\切割的行为;

当然若是派生类对象调用拷贝构造函数且派生类中并未显式定义拷贝构造函数时,对于派生类中默认生成的拷贝构造函数将会在拷贝构造时调用基类的拷贝构造函数;

默认生成的拷贝构造函数将会进行值拷贝;

---

赋值运算符重载

对于赋值运算算符重载也是如此,在调用派生类中的赋值运算符重载时若是派生类中的赋值运算符重载没有显式调用基类赋值运算符重载时,派生类将不会默认去调用基类的赋值运算符重载;

class Parent //基类
{
  public:
    //构造 - 打印 "Parent()" 
	//拷贝构造 - 打印 "Parent(const Parent& par)"
    //析构 - 打印 "~Parent()"
        Parent& operator=(const Parent& par){
      if(&par!=this){
        _name = par._name;
      }
      return *this;
    }
  protected:
    string _name;
};

class Child : public Parent  //派生类
{
  public:
    //构造 - 打印 "Child()"
    //拷贝构造 - 打印 "Child(const Child& chi))"
    //析构 - 打印 "~Child()"
    Child& operator=(const Child&chi){
      cout<<"Child&operator=()"<<endl;
      if(&chi != this){
        _age = chi._age;
      }
        return *this;
    }
  protected:
    size_t _age;
};

void test(){
    Child ch1("Lihua",18);
    Child ch2("Wang",20);
    ch2 = ch1;
}

结果 :

所以在派生类中显式定义的赋值运算符重载中需要去显式调用基类的赋值运算符重载;

 Child& operator=(const Child&chi){
      cout<<"Child&operator=()"<<endl;
      if(&chi != this){
        operator=(chi);
        _age = chi._age;
      }

但是若是在该处以这种方式对基类中的赋值运算符重载进行调用时将会造成死循环;

原因是因为,基类中的operator=()与派生类中的operator=()构成了隐藏\重定义;

所以在调用过程中由于没有使用域作用限定符进行域的指定,所以最终导无限调用派生类中的operator=();

正确方式:

• Child& operator=(const Child&chi){
        cout<<"Child&operator=()"<<endl;
        if(&chi != this){
          Parent::operator=(chi);
          _age = chi._age;
        }
  

同理,当派生类中并未显式定义赋值运算符重载时,调用派生类中的赋值运算符重载时其一样会去调用基类的赋值运算符重载,同样也只有深浅拷贝的问题;

---

析构函数

从上面几个成员函数来对析构函数进行推断时,将会显然的觉得对于析构函数来说一样也是在派生类中的析构函数去调用基类的析构函数;

~Child(){
    ~Parent();
}

但是在以这种方式去调用派生类的析构函数时将会出现编译不通过;

[一元表达式参数类型不通过]

原因是因为最终析构函数的函数名将会被处理为destructor;

所以将会构成隐藏\重定义;

只需要使用域作用限定符进行域的限制即可;

~Child(){
    Parent::~Parent();
}

在使用域作用限定符进行修饰后再次对该析构函数进行调用时析构函数将多调用一次;

因为由于需要使得析构的顺序与构造的顺序相反,在进行析构的顺序就应该为:

• 派生类析构 -> 基类析构(栈后进先出)

而若是用户自行定义的话则不一定会控制析构函数的析构顺序;

所以当派生类析构结束后会自动调用基类的析构函数;

所以派生类在进行析构时不需要去显式调用基类的析构函数;

---

继承与友元

在继承关系当中,友元关系并不会被继承;

class S ;//提前进行声明，否则在P类型中定义的友元将识别不出S类型
class P{
  public:
  friend void FuncP(const P& par,const S& chi);
  protected:
  int _age = 18;
};

class S : public P{
  public:
  protected:
  int _id = 123;
};

void FuncP(const P& par,const S& chi){
  cout<<par._age<<endl; 
  //cout<<chi._id<<endl; - error 由于友元关系并不会被继承，所以该行代码报错
}

void test_3(){
  FuncP(P(),S());//匿名对象
}

若是需要解决友元关系不能被继承的问题即可在派生类中再次定义友元即可；

---

静态成员与继承关系

在类中存在一种特殊的成员类型：

• 静态成员

该类型在类中本质上是一个公共的成员，即属于该类中的所有对象；

但是在继承当中，静态成员并没有表现出其他较为特别的性质；

当在一个基类中定义一个静态成员时;

无论该类被继承了多少次,该类中的静态成员始终为该基类与所有派生类中共同的属性;

所有继承体系当中都只有一个静态成员实例;

class Par{
  public:
    Par()
    {
      ++_count;
    }
  public:
    static int _count ;
};
int Par::_count = 0;

class Chi:Par{
public:
  Chi(){
    ++_count;
  }
  void Print(){
    cout<<Par::_count<<endl;
  }
};

void Test(){
  Chi ch1;
  ch1.Print();
}

上段代码的打印结果为2;

原因是因为由于静态成员变量是所有继承体系中共有的实例,所以当实例化一个Chi对象时调用了基类的构造函数,后又在派生类中调用了一次构造函数都对该静态成员进行了一次++,所以最终的打印结果为2;

---

中存在一种特殊的成员类型：

• 静态成员

该类型在类中本质上是一个公共的成员，即属于该类中的所有对象；

但是在继承当中，静态成员并没有表现出其他较为特别的性质；

当在一个基类中定义一个静态成员时;

无论该类被继承了多少次,该类中的静态成员始终为该基类与所有派生类中共同的属性;

所有继承体系当中都只有一个静态成员实例;

class Par{
  public:
    Par()
    {
      ++_count;
    }
  public:
    static int _count ;
};
int Par::_count = 0;

class Chi:Par{
public:
  Chi(){
    ++_count;
  }
  void Print(){
    cout<<Par::_count<<endl;
  }
};

void Test(){
  Chi ch1;
  ch1.Print();
}

上段代码的打印结果为2;

原因是因为由于静态成员变量是所有继承体系中共有的实例,所以当实例化一个Chi对象时调用了基类的构造函数,后又在派生类中调用了一次构造函数都对该静态成员进行了一次++,所以最终的打印结果为2;

---