تفسير الوراثة في C++ وأمثلة على الكود

　يمكن للتنسيق في C++ أن يكون متسلسلًا أو متعددًا، ويمكن أن يكون كل رابط متسلسلًا أو محميًا أو خاصًا أيضًا يمكن أن يكون افتراضيًا أو غير افتراضي. ثم يمكن أن تكون خيارات أعضاء الفئة افتراضية أو غير افتراضية أو افتراضية خالصة. هذه المقالة تقتصر فقط على بعض النقاط الرئيسية للتحقق.

　　التعريف العام، مثل ما يلي:

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

　　إذا كتبت بهذا الشكل، فإن المبرمج سيفهم أن نوع derived هو أيضًا نوع base، ولكن نوع base ليس نوع derived. هذا أمر مهم. لذا فإن إسم الم 参数 من نوع base يناسب derived، وإسم الم 参数 من نوع derived لا يناسب base. إليك بعض الأكواد لتحقق من ذلك، وظيفة تحتوي على م 参数 من نوع base، إذا تم إدخال derived فيها يجب أن تنجح في التنفيذ، والعكس صحيح، وظيفة تحتوي على م Parameter من نوع derived لا تناسب base.

#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("اسم هو ");
  info.append(b.getBaseName());
  info.append(", baseData هو ");
  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;
}

نتيجة التنفيذ هي:

base:اسم الأساس هو test، baseData هو 10
base:اسم الأساس هو btest، baseData هو 5

عدل الكود أدناه، قم بتحويل معامل الدالة إلى derived

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

استدعاء show(ss,d); أظهرت اللغة البرمجية خطأ

في ملف derived_class.cpp: في الدالة `int main(int, char**)':
2 derived_class.cpp:84: error: invalid initialization of reference of type 'const derived&' from expression of type 'base'
3 derived_class.cpp:70: error: in passing argument 2 of `void show2(std::string&, const derived&)'

The second point verifies various forms of inheritance, first giving a table

Inheritance method \ member type	public	protected	private
public	public	protected	Cannot inherit
protected	protected	protected	Cannot inherit
private	private	private	Cannot inherit

Here is an explanation, here it simply expresses the members of the base class, after being inherited by public, protected, and private, the members of the original base class in the inheritance class are of the type shown in the 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; 
｝

The following error is reported, indicating that testPrivate() is not a private function of derived but a private function of base

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

Below, it is verified that testProtected can be inherited by the third-level derived class, but cannot be directly called by the third-level class, which indicates that the inheritance type is protected after public inheritance, and if the base class has Public type members, they 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;
}

هنا يظهر خطأ على الخادم

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

بهذا تم التحقق من أن واحد هو public وأخر هو protected، protected لا يمكن استدعاؤه مباشرة، ولكن يمكن استدعاؤه بعد التوريث من خلال العضو public.
التفاصيل الدقيقة للتسلسل قد تُطرح إذا كنت مهتمًا بجزء التحقق، ولكن سيتم تجاهلها.

#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 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;
  cout << dpub.testPublic() << endl;
  //cout << dpub.testProtected() << endl;  //لا يمكن استخدام المستخدمين الموروثين
  //cout << dpub.testPrivate() << endl;     //الوظائف الخاصة في الكلاس الأولي
  cout << dpub.testPubPublic() << endl;
  cout << dpub.testProPublic() << 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;
｝

هذا هو جمع المعلومات حول j الوراثة في C++، سيتم إكمال المعلومات ذات الصلة لاحقًا، شكرًا للجميع على دعم هذا الموقع!

البيان: محتوى هذا المقال تم جمعه من الإنترنت، ملكية المادة للمالك الأصلي، تم إدراج المادة من قبل المستخدمين عبر الإنترنت بذاتهم، هذا الموقع لا يمتلك حقوق الملكية، لم يتم تعديل المحتوى بشكل إنساني، ولا يتحمل هذا الموقع أي مسؤولية قانونية ذات صلة. إذا اكتشفت محتوى يشتبه في انتهاك حقوق النسخ، فالرجاء إرسال بريد إلكتروني إلى: notice#oldtoolbag.com (عند إرسال البريد الإلكتروني، يرجى استبدال # ب @) للإبلاغ، وتقديم الأدلة ذات الصلة، وسيتم حذف المحتوى المزعوم عن انتهاك حقوق النسخ على الفور.