ARV I C++

Evnen til en klasse å utlede egenskaper og egenskaper fra en annen klasse kalles Arv . Arv er en av de viktigste egenskapene til objektorientert programmering.

Arv er en funksjon eller en prosess der nye klasser opprettes fra de eksisterende klassene. Den nye klassen som er opprettet kalles avledet klasse eller barneklasse, og den eksisterende klassen er kjent som basisklassen eller overordnet klasse. Den avledede klassen nå sies å være arvet fra basisklassen.

Når vi sier at avledet klasse arver basisklassen, betyr det at den avledede klassen arver alle egenskapene til basisklassen, uten å endre egenskapene til basisklassen og kan legge til nye funksjoner til sine egne. Disse nye funksjonene i den avledede klassen vil ikke påvirke basisklassen. Den avledede klassen er den spesialiserte klassen for basisklassen.

Underklasse: Klassen som arver egenskaper fra en annen klasse kalles Subclass eller Derived Class.
Superklasse: Klassen hvis egenskaper er arvet av en underklasse kalles Base Class eller Superclass.

Artikkelen er delt inn i følgende underemner:

Hvorfor og når skal man bruke arv?
Metoder for arv
Typer av arv

Hvorfor og når skal man bruke arv?

Tenk på en gruppe kjøretøy. Du må opprette klasser for buss, bil og lastebil. Metodene fuelAmount(), kapasitet(), applyBrakes() vil være de samme for alle tre klassene. Hvis vi oppretter disse klassene for å unngå arv, må vi skrive alle disse funksjonene i hver av de tre klassene som vist nedenfor:

arv i C++

javascript søvn

Du kan tydelig se at prosessen ovenfor resulterer i duplisering av samme kode 3 ganger. Dette øker sjansene for feil og dataredundans. For å unngå denne typen situasjoner brukes arv. Hvis vi oppretter en klasse Vehicle og skriver disse tre funksjonene i den og arver resten av klassene fra kjøretøyklassen, så kan vi ganske enkelt unngå duplisering av data og øke gjenbrukbarheten. Se på diagrammet nedenfor der de tre klassene er arvet fra kjøretøyklassen:

arvesøknad i C++

Ved å bruke arv, må vi skrive funksjonene bare én gang i stedet for tre ganger ettersom vi har arvet resten av de tre klassene fra basisklassen (Kjøretøy).
Implementering av arv i C++ : For å lage en underklasse som er arvet fra basisklassen må vi følge syntaksen nedenfor.

Avledede klasser: En avledet klasse er definert som klassen avledet fra basisklassen.
Syntaks :

class :  {  //body }>

Hvor
klasse — nøkkelord for å opprette en ny klasse
derived_class_name — navnet på den nye klassen, som vil arve basisklassen
tilgangsspesifikasjoner - enten privat, offentlig eller beskyttet. Hvis ingen av disse er spesifisert, tas PRIVAT som standard
base-class-name — navnet på basisklassen
Merk : En avledet klasse arver ikke adgang til private datamedlemmer. Imidlertid arver den et fullstendig overordnet objekt, som inneholder alle private medlemmer som den klassen erklærer.

Eksempel:
1. klasse ABC : privat XYZ //privat avledning
{ }
2. klasse ABC : offentlig XYZ //offentlig avledning
{ }
3. klasse ABC : beskyttet XYZ //beskyttet avledning
{ }
4. klasse ABC: XYZ //privat avledning som standard
{ }

Merk:

o Når en basisklasse arves privat av den avledede klassen, blir offentlige medlemmer av basisklassen de private medlemmene av den avledede klassen, og derfor kan de offentlige medlemmene av basisklassen bare nås av medlemsfunksjonene til den avledede klassen. De er utilgjengelige for objektene til den avledede klassen.
o På den annen side, når basisklassen er offentlig arvet av den avledede klassen, blir offentlige medlemmer av basisklassen også offentlige medlemmer av den avledede klassen. Derfor er de offentlige medlemmene av basisklassen tilgjengelige for objektene til den avledede klassen så vel som av medlemsfunksjonene til den avledede klassen.

C++

 // Example: define member function without argument within // the class #include  using namespace std; class Person {  int id;  char name[100]; public:  void set_p()  {  cout << 'Enter the Id:';  cin>> id;  cout<< 'Enter the Name:';  cin>> navn;  } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> kurs;  cout<< 'Enter the Course Fee:';  cin>> gebyr;  } void display_s() { display_p();  cout<<'Course: '<< course << '
Fee: ' << fee << endl;  } }; int main() {  Student s;  s.set_s();  s.display_s();  return 0; }>

Produksjon:

javascript streng erstatte

Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee:70000  Id: 101 Name: Dev Course: GCS Fee: 70000>

C++

 // Example: define member function without argument outside the class #include using namespace std; class Person {  int id;  char name[100];    public:  void set_p();  void display_p(); }; void Person::set_p() {  cout<<'Enter the Id:';  cin>>id;  cout<<'Enter the Name:';  cin>>navn; } void Person::display_p() { cout<> selvfølgelig;  cout<<'Enter the Course Fee:';  cin>>avgift; } void Student::display_s() { display_p();  cout<<'
Course: '<

Produksjon:

Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee: 70000 Id: 101 Name: Dev Course: GCS Fee: 70000>

C++

 // Example: define member function with argument outside the class #include #include using namespace std; class Person {  int id;  char name[100];    public:  void set_p(int,char[]);  void display_p(); }; void Person::set_p(int id,char n[]) {  this->id=id;  strcpy(dette->navn,n);  } void Person::display_p() { cout<

CPP

 // C++ program to demonstrate implementation // of Inheritance #include  using namespace std; // Base class class Parent { public:  int id_p; }; // Sub class inheriting from Base Class(Parent) class Child : public Parent { public:  int id_c; }; // main function int main() {  Child obj1;  // An object of class child has all data members  // and member functions of class parent  obj1.id_c = 7;  obj1.id_p = 91;  cout << 'Child id is: ' << obj1.id_c << '
';  cout << 'Parent id is: ' << obj1.id_p << '
';  return 0; }>

Produksjon

Child id is: 7 Parent id is: 91>

I programmet ovenfor arves 'Barn'-klassen offentlig fra 'Foreldre'-klassen, så de offentlige datamedlemmene i klassen 'Foreldre' vil også bli arvet av klassen 'Barn'.
Metoder for arv: Det er 3 moduser for arv.

Offentlig modus : Hvis vi utleder en underklasse fra en offentlig basisklasse. Da vil det offentlige medlemmet av basisklassen bli offentlig i den avledede klassen og beskyttede medlemmer av basisklassen vil bli beskyttet i den avledede klassen.
Beskyttet modus : Hvis vi utleder en underklasse fra en beskyttet basisklasse. Da vil både offentlige medlemmer og beskyttede medlemmer av basisklassen bli beskyttet i den avledede klassen.
Privat modus : Hvis vi utleder en underklasse fra en privat basisklasse. Da vil både offentlige medlemmer og beskyttede medlemmer av basisklassen bli Private i den avledede klassen.

Merk: De private medlemmene i basisklassen kan ikke fås direkte i den avledede klassen, mens beskyttede medlemmer kan fås direkte. For eksempel inneholder klassene B, C og D alle variablene x, y og z i eksemplet nedenfor. Det er bare et spørsmål om tilgang.

CPP

 // C++ Implementation to show that a derived class // doesn’t inherit access to private data members. // However, it does inherit a full parent object. class A { public:  int x; protected:  int y; private:  int z; }; class B : public A {  // x is public  // y is protected  // z is not accessible from B }; class C : protected A {  // x is protected  // y is protected  // z is not accessible from C }; class D : private A // 'private' is default for classes {  // x is private  // y is private  // z is not accessible from D };>

Tabellen nedenfor oppsummerer de tre modusene ovenfor og viser tilgangsspesifikasjonen for medlemmene av basisklassen i underklassen når de er avledet i offentlige, beskyttede og private moduser:

Typer av arv: -

Enkeltarv
Multilevel arv
Multippel arv
Hierarkisk arv
Hybrid arv

Typer av arv i C++

1. Enkeltarv : I enkeltarv har en klasse lov til å arve fra kun én klasse. dvs. én underklasse arves kun av én basisklasse.

Enkeltarv i C++

Syntaks :

class subclass_name : access_mode base_class {  // body of subclass }; OR class A {  ... .. ...  }; class B: public A { ... .. ... };>

CPP

 // C++ program to explain  // Single inheritance #include using namespace std; // base class class Vehicle {  public:  Vehicle()  {  cout << 'This is a Vehicle
';  } }; // sub class derived from a single base classes class Car : public Vehicle { }; // main function int main() {   // Creating object of sub class will  // invoke the constructor of base classes  Car obj;  return 0; }>

Produksjon

This is a Vehicle>

C++

 // Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A()  {  cout<<'Enter the Value of A=';  cin>>a;    } void disp_A() { cout<Utdata:- Angi verdien av A= 3 3 Angi verdien av B= 5 5 Produkt av 3 * 5 = 15
  
C++ // Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A(int x)  {  a=x;   }    void disp_A()  {  cout<Product of 4 * 5 = 20>
  
     2. Multippel arv:    Multiple Inheritance er en funksjon i C++ der en klasse kan arve fra mer enn én klasse. dvs. en    underklasse    er arvet fra mer enn én    grunnklasse    .
  
     Syntaks    :
 class subclass_name : access_mode base_class1, access_mode base_class2, .... {  // body of subclass }; class B {  ... .. ...  }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>
Her vil antall basisklasser være atskilt med komma (', ') og tilgangsmodus for hver basisklasse må spesifiseres.
CPP // C++ program to explain // multiple inheritance #include  using namespace std; // first base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // second base class class FourWheeler { public:  FourWheeler()  {  cout << 'This is a 4 wheeler Vehicle
';  } }; // sub class derived from two base classes class Car : public Vehicle, public FourWheeler { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base classes.  Car obj;  return 0; }>
   
  Produksjon  This is a Vehicle This is a 4 wheeler Vehicle>
  
C++ // Example: #include using namespace std; class A {  protected:  int a;    public:  void set_A()  {  cout<<'Enter the Value of A=';  cin>>a;    } void disp_A() { cout<For å vite mer om det, se artikkelen Flere arv .
   
    3. Flernivåarv    : I denne typen arv opprettes en avledet klasse fra en annen avledet klasse.
  
ikke-deterministiske endelige automater
 Syntaks:-
 class C {  ... .. ...  }; class B:public C { ... .. ... }; class A: public B { ... ... ... };>
CPP // C++ program to implement // Multilevel Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub_class derived from class vehicle class fourWheeler : public Vehicle { public:  fourWheeler()  {  cout << 'Objects with 4 wheels are vehicles
';  } }; // sub class derived from the derived base class fourWheeler class Car : public fourWheeler { public:  Car() { cout << 'Car has 4 Wheels
'; } }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base classes.  Car obj;  return 0; }>
   
  Produksjon  This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
     4. Hierarkisk arv    : I denne typen arv arves mer enn én underklasse fra en enkelt basisklasse. dvs. mer enn én avledet klasse er opprettet fra en enkelt basisklasse.
  
 Syntaks:-
 class A  {   // body of the class A.  }  class B : public A  {   // body of class B.  }  class C : public A  {   // body of class C.  }  class D : public A  {   // body of class D.  }>
CPP // C++ program to implement // Hierarchical Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base class.  Car obj1;  Bus obj2;  return 0; }>
   
  Produksjon  This is a Vehicle This is a Vehicle>
     5. Hybrid (virtuell) arv    : Hybrid arv implementeres ved å kombinere mer enn én type arv. For eksempel: Kombinere hierarkisk arv og multippel arv.  
Bildet nedenfor viser kombinasjonen av hierarkisk og multiple arv:
  
CPP // C++ program for Hybrid Inheritance #include  using namespace std; // base class class Vehicle { public:  Vehicle() { cout << 'This is a Vehicle
'; } }; // base class class Fare { public:  Fare() { cout << 'Fare of Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle, public Fare { }; // main function int main() {  // Creating object of sub class will  // invoke the constructor of base class.  Bus obj2;  return 0; }>
   
  Produksjon  This is a Vehicle Fare of Vehicle>
C++ // Example: #include   using namespace std;  class A  {   protected:   int a;   public:   void get_a()   {   cout << 'Enter the value of 'a' : ';   cin>>a;   } };    klasse B : offentlig A { beskyttet: int b;   offentlig: void get_b() { cout<< 'Enter the value of 'b' : ';  cin>>b;   } };  klasse C { beskyttet: int c;   offentlig: void get_c() { cout<< 'Enter the value of c is : ';   cin>>c;   } };    klasse D : offentlig B, offentlig C { beskyttet: int d;   offentlig: void mul() { get_a();   få_b();   get_c();   cout<< 'Multiplication of a,b,c is : ' < 
   
     6. Et spesielt tilfelle av hybridarv: Flerveisarv    :  
En avledet klasse med to baseklasser og disse to baseklassene har én felles baseklasse kalles flerveisarv. Tvetydighet kan oppstå i denne typen arv.  
    Eksempel:    
CPP // C++ program demonstrating ambiguity in Multipath // Inheritance #include  using namespace std; class ClassA { public:  int a; }; class ClassB : public ClassA { public:  int b; }; class ClassC : public ClassA { public:  int c; }; class ClassD : public ClassB, public ClassC { public:  int d; }; int main() {  ClassD obj;  // obj.a = 10; // Statement 1, Error  // obj.a = 100; // Statement 2, Error  obj.ClassB::a = 10; // Statement 3  obj.ClassC::a = 100; // Statement 4  obj.b = 20;  obj.c = 30;  obj.d = 40;  cout << ' a from ClassB : ' << obj.ClassB::a;  cout << '
 a from ClassC : ' << obj.ClassC::a;  cout << '
 b : ' << obj.b;  cout << '
 c : ' << obj.c;  cout << '
 d : ' << obj.d << '
'; }>
   
  Produksjon   a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
 I eksemplet ovenfor arver både ClassB og ClassC ClassA, de har begge en enkelt kopi av ClassA. Klasse-D arver imidlertid både ClassB og ClassC, derfor har Class-D to kopier av ClassA, en fra ClassB og en annen fra ClassC.  
Hvis vi trenger å få tilgang til datamedlemmet til ClassA gjennom objektet til Klasse-D, må vi spesifisere banen som a vil få tilgang fra, enten det er fra ClassB eller ClassC, bcoz-kompilatoren kan ikke skille mellom to kopier av ClassA i Klasse-D.
 Det er 2 måter å unngå denne tvetydigheten på:         
    1) Unngå tvetydighet ved å bruke scope resolution operator:    Ved å bruke scope resolution-operatoren kan vi manuelt spesifisere banen som datamedlem a vil få tilgang fra, som vist i setningene 3 og 4, i eksemplet ovenfor.
CPP obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
    
      Merk:      Likevel er det to eksemplarer av ClassA i klasse-D.  
    2) Unngå tvetydighet ved å bruke den virtuelle baseklassen:     
syreegenskaper database
CPP #include class ClassA {  public:  int a; }; class ClassB : virtual public ClassA {  public:  int b; }; class ClassC : virtual public ClassA {  public:  int c; }; class ClassD : public ClassB, public ClassC {  public:  int d; }; int main() {  ClassD obj;  obj.a = 10; // Statement 3  obj.a = 100; // Statement 4  obj.b = 20;  obj.c = 30;  obj.d = 40;  cout << '
 a : ' << obj.a;  cout << '
 b : ' << obj.b;  cout << '
 c : ' << obj.c;  cout << '
 d : ' << obj.d << '
'; }>
      Produksjon:    
 a : 100 b : 20 c : 30 d : 40>
I følge eksemplet ovenfor har Klasse-D bare én kopi av KlasseA, derfor vil setning 4 overskrive verdien av a gitt i setning 3.

TechCodeview

Hvorfor og når skal man bruke arv?

Merk:

Typer av arv: -

Typer av arv i C++

Det er 2 måter å unngå denne tvetydigheten på: