[C++] In-depth understanding of the basic knowledge of inheritance and its relationship with access qualifiers

The relationship between inheritance methods and access qualifiers

Three inheritance methods:

1. Public inheritance

2. Private inheritance

3. Protected inheritance

Relationship: If the member function of the base class is private, the derived class’s private member of the base class is Invisible, other criteria are limited to a small selection range for final access.

Protected member qualifier: Some base class members do not want to be directly accessed by objects of the base class, but need to be accessed in the derived class, they are defined as protected members. Protected member qualifiers arise because of inheritance.

Understanding Hiding

Hiding means that the function of the derived class blocks the base class function with the same name. The rules are as follows:

1. If the function of the derived class has the same name as the function of the base class, but the parameters are different, at this time, the function of the base class will be hidden regardless of the virtual keyword.

2. If the function of the derived class has the same name as the function of the base class, and the parameters are also the same, but the base class function does not have the virtual keyword, then the function of the base class is hidden.

Default member functions of derived classes

If the six default member functions are not explicitly defined in the derived class, the compilation system will synthesize these six member functions by default.

1. Constructor

2. Copy constructor

3. Destructor

4. Assignment operator overloading

5. Address operator overloading

6. const modified address operator overloading

#include<iostream>
using namespace std;
class person{
  public:
    person(const char* name)
      :_name(name)
    {
      cout<<"person()"<<endl;
    }
    person(const person& p){
      cout<<"person(const person& p)"<<endl;
    }
    person& operator=(const person& p){
      cout<<"person& operator=(const person& p)"<<endl;
      if(this!=&p){
        _name=p._name;
      }
      return *this;
    }
    ~person(){
     cout<<"~person()"<<endl; 
    }
  protected:
    string _name;
};
class student:public person{
  public:
    student(const char* name,int num)
      :person(name)
       ,_num(num){
         cout<<"student()"<<endl;
       }
    student(const student& s)
      :person(s)
       ,_num(s._num)
    {
      cout<<"student(const student& s)"<<endl;
    }
    student& operator=(const student& s){
      cout<<"student& operator=(const student& p)"<<endl;
      if(this!=&s){
        person::operator=(s);//必须指定域，否则会死循环
        _num=s._num;
      }
      return *this;
    }
    ~student(){//析构的时候先清理子类，再清理父类，不需要显示的调用
      cout<<"~student()"<<endl;
    }
  private:
    int _num;
};
int main(){
  student s1("jack",18);
  student s2(s1);
  student s3("rose",16);
  s1=s3;
}

Diamond inheritance

Diamond inheritance has problems of ambiguity and data redundancy.

For example, the inherited data in the figure below is two copies, each different:

Solution: virtual inheritance

In the diamond Add virtual

to the second layer. Example:

Related articles:

C# Tips on missing items (4): Inherit

#C# Basic knowledge arrangement: Basic knowledge (2) Category

Related videos:

Qianfeng C language basics Video tutorial

The above is the detailed content of [C++] In-depth understanding of the basic knowledge of inheritance and its relationship with access qualifiers. For more information, please follow other related articles on the PHP Chinese website!