Quelle est la méthode d’héritage par défaut pour les classes dérivées ?

Laissez-moi d'abord répondre à vos questions : il existe deux méthodes d'héritage par défaut pour les classes dérivées. Utilisez class pour définir une classe dérivée et la méthode d'héritage par défaut est privée. Utilisez struct pour définir une classe dérivée et la méthode d'héritage par défaut est publique.

Tutoriel recommandé : Tutoriel vidéo C++

L'héritage est la deuxième fonctionnalité majeure de la programmation orientée objet. création de nouvelles classes basées sur des classes existantes.La nouvelle classe peut hériter des données membres et des fonctions membres de la classe existante, ajouter ses propres données membres et fonctions membres uniques et redéfinir les fonctions membres de la classe existante. L’utilisation de l’héritage et de la dérivation de classes pour atteindre un niveau plus élevé de réutilisabilité du code est conforme aux idées du développement logiciel moderne.

Le langage C++ prend en charge à la fois l'héritage unique et l'héritage multiple. L'héritage unique signifie qu'une classe dérivée hérite d'une seule classe de base ; en conséquence, l'héritage multiple signifie qu'une classe dérivée hérite de deux ou plusieurs classes de base en même temps. Java ne prend en charge que l'héritage unique.

1. Classe dérivée

Le format de définition de la classe dérivée est le suivant :

      class <派生类名>：[继承方式]<基类名1>
            [，[继承方式]<基类名2>，...，[继承方式]<基类名n>]
      {
              <派生类新增的数据成员和成员函数定义>
      };

Description :

(1) Le mot-clé pour définir une classe dérivée peut être class ou struct La différence entre les deux est : utilisez class pour définir une classe dérivée, la méthode d'héritage par défaut est private, utilisez struct. pour définir une classe dérivée, la méthode d'héritage par défaut est publique. Les attributs par défaut des membres nouvellement ajoutés sont également la classe correspondant aux attributs privés et la structure correspondant aux attributs publics.

(2) Les deux types de fonctions dont une classe de base ne peut pas hériter d'une classe dérivée sont les constructeurs et les destructeurs.

2. Accédez aux attributs des membres de la classe de base dans les classes dérivées sous 3 méthodes d'héritage

继承描述符	父public成员	父protected成员	父private成员
public	子public成员	子protected成员	-
protected	子protected成员	子protected成员	-
private	子private成员	子private成员	-

Utilisez le code suivant pour comprendre brièvement :

#include "stdafx.h"
#include<iostream>
 using namespace std; 
 class Base
 {
 private:
     int priData;
 9 protected:
    int proData;
 public:
    int pubData;
 };

class D1:private Base//私有继承
 {
    void f1()
     {
        //priData=1;//基类private成员在派生类中不可直接访问
        proData=2;//基类的protected成员在派生类中为private访问属性
         pubData=3;//基类的public成员在派生类中为private访问属性
    }
 };
 class D2:protected Base//保护继承
 {
     void f2()
    {
         //priData=1;//基类private成员在派生类中不可直接访问
        proData=2;//基类的protected成员在派生类中为protected访问属性
         pubData=3;//基类的public成员在派生类中为protected访问属性
     }
 };
 
 class D3:public Base//公有继承
 {
    void f3()
     {
        //priData=1;//基类private成员在派生类中不可直接访问
         proData=2;//基类的protected成员在派生类中为protected访问属性
        pubData=3;//基类的public成员在派生类中为public访问属性
     }
 };
 
 int main()
 {
     Base obj;
    //obj.priData=1;//对象不可访问Base类中private成员
     //obj.proData=2;//对象不可访问Base类中protected成员
    obj.pubData=3;
   D1 objD1;
    //objD1.pubData=3;//private属性，不可访问
    D2 objD2;
     //objD2.pubData=3;//protected属性，不可访问
    D3 objD3;
     objD3.pubData=3;//public属性，可以访问
    return 0;
}

Bien que les fonctions membres privées de la classe de base ne soient pas directement accessibles dans les fonctions membres de la classe dérivée, les fonctions membres de la classe dérivée peuvent accéder indirectement à ces membres en appelant les fonctions héritées de la classe de base. Si une fonction de la classe de base est héritée et reste membre public de la classe dérivée, elle peut être appelée directement via l'objet de classe dérivée.

Jetons d'abord un coup d'œil aux attributs d'accès et aux fonctions des membres de la classe :

访问属性	作用
private	只允许该类的成员函数及友元函数访问，不能被其他函数访问
protected	既允许该类的成员函数及友元函数访问，也允许其派生类的成员函数访问
public	既允许该类的成员函数访问，也允许类外部的其他函数访问

Eh bien, continuez à comprendre à travers le code :

#include "stdafx.h"
 #include<iostream>
 using namespace std;
 
class Base
 {
 private:
     int priData;
 protected:
    int proData;
 public:
     int pubData;
 //在类的定义中不能对数据成员进行初始化
     void SetData()//为基类中的数据成员赋值
     {
         priData=100;
        proData=200;
         pubData=300;
    }
    void Print()
     {
        cout<<"priData="<<priData<<endl;
       cout<<"proData="<<proData<<endl;
        cout<<"pubData="<<pubData<<endl;
     }
 };

 class Derived:public Base
 {
 public:
     void ChangeData()
     {
         SetData();
         proData=12;//在派生类的成员函数类可以访问基类的非私有成员                   
     }
 };

 int main()
 {
    Base b;
     b.SetData();
     b.Print();
 
     Derived d1;
     d1.ChangeData();
     d1.pubData=13;
    d1.Print();
     
     return 0;
 }

Les résultats de l'exécution du programme sont les suivantes :

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!