[C++] Compréhension approfondie des connaissances de base sur l'héritage et sa relation avec les qualificateurs d'accès

La relation entre les méthodes d'héritage et les qualificatifs d'accès

Trois méthodes d'héritage :

1. Héritage public

2. Héritage privé

3. Héritage protégé

Relation : Si la fonction membre de la classe de base est privée, les membres privés de la classe dérivée à la Les classes de base sont invisibles, les autres critères sont limités à une petite plage de sélection pour l'accès final.

Qualificateur de membre protégé : certains membres de la classe de base ne souhaitent pas être directement accessibles par les objets de la classe de base, mais doivent être accessibles dans la classe dérivée, ils sont définis comme membres protégés. Les qualificatifs de membres protégés surviennent en raison de l’héritage.

Comprendre le masquage

Le masquage signifie que la fonction de classe dérivée bloque la fonction de classe de base portant le même nom. Les règles sont les suivantes :

1. Si la fonction de la classe dérivée a le même nom que la fonction de la classe de base, mais que les paramètres sont différents, à ce moment, la fonction de la classe de base sera masquée quel que soit le mot-clé virtuel.

2. Si la fonction de classe dérivée a le même nom que la fonction de classe de base et que les paramètres sont les mêmes, mais que la fonction de classe de base n'a pas le mot-clé virtuel, alors la fonction de classe de base est caché.

Fonctions membres par défaut des classes dérivées

Si les six fonctions membres par défaut ne sont pas explicitement définies dans la classe dérivée, le système de compilation synthétisera ces six fonctions membres par défaut .

1. Constructeur

2. Constructeur de copie

3. Destructeur

4. Surcharge d'opérateur d'affectation

5. Surcharge d'opérateur d'adresse

6. Surcharge d'opérateur d'adresse modifiée Const

#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;
}

Héritage diamant

L'héritage diamant présente des problèmes d'ambiguïté et de redondance des données.

Par exemple, les données héritées dans la figure ci-dessous sont deux copies chacune différente :

Solution : héritage virtuel

dans le diamant Ajoutez virtual

à la deuxième couche Exemple :

Articles connexes :

Conseils sur C# (4) : Héritage

Compilation des connaissances de base C# : connaissances de base (2) Classe

Vidéos associées :

Vidéo sur les bases du langage C Qianfeng tutoriel

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!