Arv är ett grundläggande begrepp inom OOP (Objektorienterad programmering) . Det är den mekanism genom vilken en klass tillåts ärva egenskaperna (fält och metoder) från en annan klass. Arv innebär att skapa nya klasser baserade på befintliga. En klass som ärver från en annan klass kan återanvända den klassens metoder och fält.

Exempel: I följande exempel är Djur basklassen och Hund Katt och Ko är härledda klasser som utökar klassen Djur.

#include    using namespace std; class Animal {  public:  void sound()  {  cout << 'Animal makes a sound' << endl;  } }; class Dog : public Animal {  public:  void sound()  {  cout << 'Dog barks' << endl;  } }; class Cat : public Animal {  public:  void sound()  {  cout << 'Cat meows' << endl;  } }; class Cow : public Animal {  public:  void sound()  {  cout << 'Cow moos' << endl;  } }; int main() {  Dog d;  d.sound();  Cat c;  c.sound();  Cow cow;  cow.sound();  return 0; } 

Dog barks Cat meows Cow moos 

Förklaring:

• Animal är basklassen med en funktion sound().
• Dog Cat och Cow är härledda klasser som var och en definierar sin egen sound()-metod.
• I main() skapas objekt av Dog Cat och Cow separat.
• När vi anropar sound() på varje objekt körs respektive barnklassmetod (Hund skäller Katt jamar Cow moos).

Syntax

class ChildClass : public ParentClass {  // Additional fields and methods }; 

Hur Arv fungerar i C++?

Kolon (:) med en åtkomstspecifikation används för arv i C++. Den tillåter den härledda klassen (underklassen) att ärva datamedlemmarna (fälten) och medlemsfunktionerna (metoderna) för basklassen (förälderklassen).
När en klass ärver en annan klass får den alla tillgängliga medlemmar i den överordnade klassen och den underordnade klassen kan också omdefiniera (åsidosätta) eller lägga till ny funktionalitet till dem.

hur man konverterar sträng till int i java

Typer av arv i C++

Nedan är de olika typerna av arv som stöds av C++.

1. Enstaka arv

Vid enkelarv härleds en underklass från endast en superklass. Den ärver egenskaperna och beteendet hos en ensamförälderklass. Ibland är det också känt som enkelt arv.

#include    using namespace std; class Vehicle { public:  Vehicle() {  cout << 'This is a Vehicle' << endl;  } }; class Car : public Vehicle { public:  Car() {  cout << 'This Vehicle is Car' << endl;  } }; int main() {    Car obj;  return 0; } 

This is a Vehicle This Vehicle is Car 

2. Multipelt arv

I Multipelt arv en klass kan ha mer än en superklass och ärva funktioner från alla överordnade klasser.

#include    using namespace std; class LandVehicle {  public:  void landInfo()  {  cout << 'This is a LandVehicle' << endl;  } }; class WaterVehicle {  public:  void waterInfo()  {  cout << 'This is a WaterVehicle' << endl;  } }; // Derived class inheriting from both base classes class AmphibiousVehicle : public LandVehicle public WaterVehicle {  public:  AmphibiousVehicle()  {  cout << 'This is an AmphibiousVehicle' << endl;  } }; int main() {  AmphibiousVehicle obj;  obj.waterInfo();  obj.landInfo();  return 0; } 

This is an AmphibiousVehicle This is a WaterVehicle This is a LandVehicle 

3. Arv på flera nivåer

Flernivåarv i C++ betyder att en klass härrör från en annan härledd klass som bildar en arvskedja.

#include    using namespace std; class Vehicle {  public:  Vehicle()  {  cout << 'This is a Vehicle' << endl;  } }; // Derived class from Vehicle class FourWheeler : public Vehicle {  public:  FourWheeler()  {  cout << '4 Wheeler Vehicles' << endl;  } }; // Derived class from FourWheeler class Car : public FourWheeler {  public:  Car()  {  cout << 'This 4 Wheeler Vehicle is a Car' << endl;  } }; int main() {  Car obj;  return 0; } 

This is a Vehicle 4 Wheeler Vehicles This 4 Wheeler Vehicle is a Car 

4. Hierarkiskt arv

I hierarkiskt arv ärvs mer än en underklass från en enda basklass. d.v.s. mer än en härledd klass skapas från en enda basklass. Till exempel bilar och bussar är båda fordon.

#include    using namespace std; class Vehicle {  public:  Vehicle()  {  cout << 'This is a Vehicle' << endl;  } }; class Car : public Vehicle {  public:  Car()  {  cout << 'This Vehicle is Car' << endl;  } }; class Bus : public Vehicle {  public:  Bus()  {  cout << 'This Vehicle is Bus' << endl;  } }; int main() {  Car obj1;  Bus obj2;  return 0; } 

This is a Vehicle This Vehicle is Car This is a Vehicle This Vehicle is Bus 

5. Hybrid arv

När två eller flera typer av arv kombineras i ett program. Till exempel kan en klass använda multipelt arv och även vara en del av en flernivåarvskedja.

#include    using namespace std; class Vehicle {  public:  Vehicle()  {  cout << 'This is a Vehicle' << endl;  } }; class Fare {  public:  Fare()  {  cout << 'Fare of Vehicle' << endl;  } }; class Car : public Vehicle {  public:  Car()  {  cout << 'This Vehical is a Car' << endl;  } }; class Bus : public Vehicle public Fare {  public:  Bus()  {  cout << 'This Vehicle is a Bus with Fare';  } }; int main() {  Bus obj2;  return 0; } 

This is a Vehicle Fare of Vehicle This Vehicle is a Bus with Fare

Hybrid arv kan leda till diamantproblem i C++. Detta händer när en klass ärver från två klasser som båda delar samma basklass. Som ett resultat får den härledda klassen flera kopior av basklassmedlemmarna vilket skapar oklarhet om vilken som ska användas.

Obs: Lösningen är att använda virtuellt arv så att endast en enda kopia av basklassen delas.

Fördelar med arv i C++

• Kod Återanvändbarhet : Härledd klass kan direkt återanvända datamedlemmar och metoder för sin basklass för att undvika kodduplicering.
• Abstraktion: Stöder abstrakta klasser (klasser med rena virtuella funktioner) som definierar ett gemensamt gränssnitt som upprätthåller abstraktion.
• Klasshierarki: Du kan bygga hierarkier (bas → härledd → vidare härledd) för att modellera verkliga relationer.
• Polymorfism: Stöder helt runtime polymorfism genom virtuella funktioner och även kompileringstid polymorfism via funktionsöverbelastning och mallar.

Nackdelar med arv i C++

• Tät koppling: Barnklassen blir beroende av föräldraklassen. Varje förändring i basklassen kan tvinga fram ändringar i härledda klasser.
• Minskad flexibilitet: Ibland missbrukas arv där sammansättning (har-ett förhållande) skulle vara bättre vilket leder till mindre flexibel kod.
• Ökad komplexitet: Djupa arvshierarkier (flernivå eller hybrid) kan göra koden svår att förstå underhålla och felsöka.
• Diamantproblem: Med hybrid eller multipel nedärvning kan tvetydighet uppstå om samma basklass ärvs flera gånger.
• Overhead av virtuella funktioner: Om polymorfism (virtuella funktioner) används finns det en liten runtime-overhead på grund av virtuella tabelluppslagningar.