C++ Explication détaillée et exemples de code d'héritage

　C++l'héritage peut être héréditaire ou multiple, chaque lien d'héritage peut être public, protected, privé, ou virtual ou non-virtual. Ensuite, les options des fonctions membres peuvent être virtual ou non-virtual ou pure virtual. Cet article ne fait que vérifier quelques points clés.

　　héritage public, par exemple :

1 class base
2 {...}
3 class derived:public base
4 {...}

　　Si ainsi, le compilateur comprendra que l'objet de type derived est également de type base, mais que l'objet de type base n'est pas de type derived. Cela est très important. Alors, les arguments de type base conviennent à derived, mais les arguments de type derived ne conviennent pas à base. Voici un code de vérification, une fonction avec un argument de type base, lorsqu'elle reçoit derived, elle peut exécuter avec succès, inversement, une fonction avec un argument de type derived

#include <iostream>
#include <stdio.h>
class base
{
  public:
  base()
  :baseName(""),baseData(0)
  {}
  base(std::string bn,int bd)
  :baseName(bn),baseData(bd)
  {}
  std::string getBaseName() const
  {
    return baseName;
  }
  int getBaseData()const
  {
    return baseData;
  }
  private:
    std::string baseName;
    int baseData;
};
class derived:public base
{
  public:
    derived():base(),derivedName("")
    {}
    derived(std::string bn,int bd,std::string dn)
    :base(bn,bd),derivedName(dn)
    {}
    std::string getDerivedName() const
    {
      return derivedName;
    }
  private:
    std::string derivedName;
};
void show(std::string& info,const base& b)
{
  info.append("Nom est ");
  info.append(b.getBaseName());
  info.append(", baseData est ");
  char buffer[10];
  sprintf(buffer,"%d",b.getBaseData());
    info.append(buffer);
}
int main(int argc, char* argv[])
{
  base b("test",10);
  std::string s;
  show(s,b);
  std::cout<<s<<std::endl;
  derived d("btest",5,"dtest");
  std::string ss;
  show(ss,d);
  std::cout<<ss<<std::endl;
  return 0;
}

Résultat de l'exécution :

base: baseName est test, baseData est 10
base: baseName est btest, baseData est 5

Modifiez le code, changez le paramètre de la fonction en derived

void show2(std::string& info,const derived& d)
{
  info.append("Nom est ");
  info.append(d.getBaseName());
  info.append(", baseData est ");
  char buffer[10];
  sprintf(buffer,"%d",d.getBaseData());
  info.append(buffer);
}

Appel de show(ss,d); erreur de compilateur

1 derived_class.cpp: Dans la fonction `int main(int, char**) :
2 derived_class.cpp:84: erreur: initialisation invalide d'une référence de type 'const derived&' à partir de l'expression de type 'base'
3 derived_class.cpp:70: erreur: en passant l'argument 2 de `void show2(std::string&, const derived&)

Le deuxième point vérifie diverses formes d'héritage, tout d'abord, voici un tableau

Méthode d'héritage\Type de membre	public	protected	private
public	public	protected	Inhéritage impossible
protected	protected	protected	Inhéritage impossible
private	private	private	Inhéritage impossible

Voici une explication, ici il s'agit simplement des membres de la classe de base, hérités par les trois méthodes public, protected et private, les membres de la classe de base en tant que public, protected et private deviennent de type tableau dans le contenu de la table

class base
{
  public:
    std::string testPublic()
    {
      return std::string("this is public base");
    }
  protected:
    std::string testProtected()
    {
      return std::string("this is protected base");
    }
  private:
    std::string testPrivate()
    {
      return std::string("this is private base");
    }
};
class derivedPublic:public base
{
  public:
    std::string testPubPublic()
    {
      return testPublic()+= "in derived";
    }
    std::string testProPublic()
    {  
      return testProtected()+= "in derived";
    }
    std::string testPriPublic()          
    {  
      return testPrivate()+= "in derived";
    }
};
int main(int argc, char* argv[])
｛
  derivedPublic dpub;
  std::cout << dpub.testPublic() << std::endl; 
｝

Report the following error, indicating that testPrivate() is not a derived private function but a base private function

derived11.cpp:16: error: `std::string base::testPrivate()' is private
derived11.cpp:36: error: within this context

This verifies that private type members cannot be inherited (public, private, protected). Note: private and protected are omitted from the proof.

We only need to verify that testProtected can be inherited by the third-level derived class but cannot be called directly by the third-level class, which means that it is inherited after public inheritance and the inheritance type is protected, while the base class has public type members that can be inherited and can be called directly.

#include <iostream>
#include <string>
class base
{
  public:
    std::string testPublic()
    {
      return std::string("this is public base");
    }
  protected:
    std::string testProtected()
    {
      return std::string("this is protected base");
    }
  private:
    std::string testPrivate()
    {
      return std::string("this is private base");
    }
};
class derivedPublic:public base
{
  public:
    std::string testPubPublic()
    {
      return testPublic()+= "in derived";
    }
    std::string testProPublic()
    {  
      return testProtected()+= "in derived";
    }
//    std::string testPriPublic()          
//    {  
//      return testPrivate()+= "in derived";
//    }
};
class deepDerived:public derivedPublic
{
  public:
    std::string deepProtected()
    {
      return testProtected() +="in deep";
    }
    std::string deepPublic()
    {
      return testPublic() +="indeep";
    }
};
int main(int argc, char* argv[])
{
  derivedPublic dpub;
  std::cout << dpub.testProtected() << std::endl; 
  deepDerived deepdpub;
  std::cout << deepdpub.testPublic() << std::endl;
  std::cout << deepdpub.testProtected() << std::endl;
  std::cout << deepdpub.deepProtected() << std::endl;
  std::cout << deepdpub.deepPublic() << std::endl;
}

Here the server reports an error

derived12.cpp:13: error: `std::string base::testProtected()' is protected
derived12.cpp:62: error: within this context

This verifies that one is public and the other is protected. Protected cannot be called directly, but it can be called by public members after inheritance.
The detailed steps are omitted here as they have been proven, but if you are interested in this part of the verification, you can see the code below.

#include <iostream>
#include <string>
class base
{
  public:
    std::string testPublic()
    {
      return std::string("this is public base");
    }
  protected:
    std::string testProtected()
    {
      return std::string("this is protected base");
    }
  private:
    std::string testPrivate()
    {
      return std::string("this is private base");
    }
};
class derivedPublic:public base
{
  public:
    std::string testPubPublic()
    {
      return testPublic()+= "in derived";
    }
    std::string testProPublic()
    {  
      return testProtected()+= "in derived";
    }
//    std::string testPriPublic()          //Les membres privés n'ont pas été hérités
//    {  
//      return testPrivate()+= "in derived";
//    }
};
class deepDerived:public derivedPublic
{
  public:
    std::string test()
    {
      return testPublic() +="in 3";
    }
};
class derivedProtected:protected base
{
  public:
    std::string testPubProtected()
    {
      return testPublic()+= "in derived";
    }
    std::string testProProtected()
    {  
      return testProtected()+= "in derived";
    }
};
class deepDerived2:public derivedProtected
{
  public:
    std::string test()
    {
      return testPublic() +="in 3";
    }
};
class derivedPrivate:private base
{
  public:
    std::string testPubPirvate()
    {
      return testPublic()+= "in derived";
    }
    std::string testProPrivate()
    {  
      return testProtected()+= "in derived";
    }
};
//class deepDerived3:public derivedPrivate
//{
//  public:
//    std::string test()
//    {
//      return testPublic() +="in 3";
//    }
//};
int main(int argc, char* argv[])
{
  derivedPublic dpub;
  //derivedProtected dpro;
  //derivedPrivate dpri;
  std::cout << dpub.testPublic() << std::endl;    //
  //std::cout << dpub.testProtected() << std::endl;  //L'utilisateur hérité ne peut pas être utilisé
  //cout << dpub.testPrivate() << std::endl;     //les classes de base sont toutes des fonctions privées
  std::cout<<dpub.testPubPublic()<<std::endl;
  std::cout<<dpub.testProPublic()<<std::endl;
  //std::cout<<dpub.testPriPrivate()<<std::endl; //n'est pas hérité
  deepDerived dd;
  std::cout<<dd.test()<<std::endl;
  derivedProtected dpro;
  //std::cout<<dpro.testPublic()<<std::endl;    //devient un type protégé
  std::cout<<dpro.testPubProtected()<<std::endl;
  std::cout<<dpro.testProProtected()<<std::endl;
  deepDerived2 dd2;
  std::cout<<dd2.test()<<std::endl;
  derivedPrivate dpri;
  std::cout<<dpri.testPubPirvate()<<std::endl;
  std::cout<<dpri.testProPrivate()<<std::endl;
//  deepDerived3 dd3;
//  std::cout<<dd3.test()<<std::endl;
｝

Voici la définition de C++ Rédaction des documents hérités de j, continuera à compléter les documents pertinents, merci de votre soutien à ce site !

Déclaration : Le contenu de cet article est extrait du réseau, la propriété intellectuelle appartient aux auteurs respectifs, le contenu est apporté par les utilisateurs d'Internet et téléchargé spontanément. Ce site n'possède pas de propriété, n'a pas été édité par l'homme, et n'assume pas la responsabilité des responsabilités juridiques pertinentes. Si vous trouvez du contenu suspect de violation de droits d'auteur, veuillez envoyer un e-mail à : notice#oldtoolbag.com (veuillez remplacer # par @ lors de l'envoi d'un e-mail pour signaler une violation, et fournir des preuves pertinentes. Une fois confirmée, ce site supprimera immédiatement le contenu suspect de violation de droits d'auteur.)