C++ Erklärung und Beispielcode zur Vererbung

　C++Vererbung kann singuläre Vererbung oder mehrfache Vererbung sein, jede Vererbungsverbindung kann public, protected, private sein und kann virtual oder non sein-virtual. Dann sind die Optionen für die einzelnen Memberfunktionen virtual oder non-virtual oder pure virtual. In diesem Artikel werden nur einige wichtige Punkte überprüft.

　　public Vererbung, zum Beispiel:

1 class base
2 ｛...｝
3 class derived:public base
4 ｛...｝

　　Wenn dies so geschrieben wird, versteht der Compiler, dass ein Objekt vom Typ "derived" gleichzeitig ein Objekt vom Typ "base" ist, aber ein Objekt vom Typ "base" ist nicht ein Objekt vom Typ "derived". Dies ist sehr wichtig. Dann ist ein Funktionsparameter vom Typ "base" für "derived" geeignet, aber ein Funktionsparameter vom Typ "derived" ist nicht für "base" geeignet. Hier ist das Validierungscode, eine Funktion mit einem Parameter vom Typ "base", der ein "derived" übergeben wird, sollte erfolgreich ausgeführt werden, im Gegenteil, eine Funktion mit einem Parameter vom Typ "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("Name ist ");
  info.append(b.getBaseName());
  info.append(", baseData ist ");
  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;
}

Laufende Ergebnisse:

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

Ändern Sie den Code, um die Funktion parameter in derived zu ändern

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

Aufruf von show(ss,d); Der Compiler gibt einen Fehler aus

1 derived_class.cpp: In der Funktion `int main(int, char**)':
2 derived_class.cpp:84: Fehler: ungültige Initialisierung eines Referenztyps 'const derived&' aus Ausdruckstyp 'base'
3 derived_class.cpp:70: Fehler: bei der Übergabe des Arguments 2 von `void show2(std::string&, const derived&)

Der zweite Punkt überprüft verschiedene Formen der Vererbung, gibt zunächst eine Tabelle an

Vererbungsart \ Mitgliedsart	public	protected	private
public	public	protected	Kann nicht vererbt werden
protected	protected	protected	Kann nicht vererbt werden
private	private	private	Kann nicht vererbt werden

Hier wird erläutert, dass hier nur die Mitglieder der Basisklasse ausgedrückt werden, die nach dem Vererben durch die Arten public, protected und private in der ursprünglichen Basisklasse, in der die Mitglieder in der Vererbungsklasse die Typen im Tabelleninhalt haben

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 proof.

Below, it is only verified that testProtected can be inherited by the third-level derived class, but cannot be called directly by the third-level class, which indicates that it is a protected type after public inheritance, and if the base class is of Public type, its members can be inherited and directly called.

#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.
Below is already proven, the detailed steps are omitted. 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()          //Die privaten Member wurden nicht vererbt
//    {  
//      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;  //Der Benutzer kann auch nicht auf die Vererbung zugreifen
  //cout << dpub.testPrivate() << std::endl;     //基类都是私有函数
  std::cout << dpub.testPubPublic() << std::endl;
  std::cout << dpub.testProPublic() << std::endl;
  //std::cout << dpub.testPriPrivate() << std::endl; //未继承
  deepDerived dd;
  std::cout << dd.test() << std::endl;
  derivedProtected dpro;
  //std::cout << dpro.testPublic() << std::endl;    //变为protected类型
  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;
｝

以上就是对C++ j继承的资料整理，后续将继续补充相关资料，感谢大家对本站的支持！

声明：本文内容来自网络，版权属于原作者。内容由互联网用户自发贡献并自行上传，本网站不拥有所有权，未进行人工编辑处理，也不承担相关法律责任。如果您发现涉嫌版权的内容，请发送邮件至：notice#oldtoolbag.com（在发送邮件时，请将#替换为@进行举报，并提供相关证据。一经查实，本站将立即删除涉嫌侵权的内容。）