I denne artikkelen skal vi diskutere arvskonseptet i C ++ - programmering. Vi vil forklare begrepet vennefunksjonen i C ++ med eksempler på arbeid.
Hvorfor arv?
Arv gjør det mulig å opprette en ny klasse eller avledet klasse fra en annen klasse eller baseklasse. Den avledede klassen eller barneklassen vil ha alle funksjonene i foreldreklassen eller grunnklassen. Vi kan bruke koden på nytt ved hjelp av arv.
Type arv
Det er forskjellige typer arv:
- Enkel/enkel arv
- Hierarkisk arv
- Arv på flere nivåer
- Flere arv
I denne artikkelen skal vi bare vurdere enkel/enkel arv.
Eksempel 1:
La oss nå se på et eksempelprogram for å forstå arvebegrepet i C ++. Vi har definert en basisklasse og deretter avledet en annen klasse fra den. Derfor vil den avledede klassen ha funksjonene (medlemmer og funksjoner) fra basisklassen.
#inkludereved hjelp av navneområde std;
klasse Base_Class
{
offentlig:
intJeg;
tomromvise()
{
koste<< 'Visning av basisklasse' <<Jeg<<endl;
}
};
klasse Derived_Class:offentlig Base_Class
{
offentlig:
tomromforestilling()
{
koste<< 'Show of Derived Class' <<endl;
}
};
inthoved-()
{
Derived_Class dc;
dc.Jeg = 100;
dc.vise();
dc.forestilling();
komme tilbake 0;
}
Eksempel 2:
Dette er et annet eksempel på arv i C ++. I dette eksemplet skal vi se hvordan konstruktørene kalles når et avledet klasseobjekt opprettes.
Som du kan se nedenfor, har vi definert to baseklasse konstruktører og tre avledede klasse konstruktører. Du kan tydelig merke fra utgangen nedenfor at baseklassen konstruktøren kalles først før den avledede klasse konstruktøren kalles.
#inkludereved hjelp av navneområde std;
klasse Base_Class
{
offentlig:
Base_Class()
{
koste<< 'Base_Class - Ingen parametere' <<endl;
}
Base_Class(intx)
{
koste<< 'Base_Class - Parametere:' <<x<<endl;
}
};
klasse Derived_Class:offentlig Base_Class
{
offentlig:
Derived_Class()
{
koste<< 'Derived_Class - Ingen parametere' <<endl;
}
Derived_Class(intog)
{
koste<< 'Derived_Class - Parametere:' <<og<<endl;
}
Derived_Class(intx,intog):Base_Class(x)
{
koste<< 'Param of Derived_Class:' <<og<<endl;
}
};
inthoved-()
{
Derived_Class d(7,19);
}
Eksempel 3:
I dette eksemplet skal vi se hvordan avledede klasseobjekter kan brukes.
Som du kan se, er det to klasser definert: Rectangle_Class og Cube_Class. Rectangle_Class er basisklassen som den avledede klassen, dvs. Cube_Class er avledet fra. Derfor arver vi funksjonene fra Rectangle_Class til Cube_Class.
Du kan også legge merke til at vi arver Cube_Class med offentlig tilgangskontroll. Dette betyr at den avledede klassen kan få tilgang til alle de ikke-private medlemmene av basisklassen.
Vi har erklært et objekt for den avledede klassen, og kaller deretter metodene fra basisklassen, dvs. setLength () og setBreadth ().
#inkludereved hjelp av navneområde std;
class Rectangle_Class
{
privat:
intlengde;
intbredde;
offentlig:
Rectangle_Class();
Rectangle_Class(intde,intb);
Rectangle_Class(Rectangle_Class&r);
intgetLength()
{
komme tilbakelengde;
}
intgetBreadth()
{
komme tilbakebredde;
}
tomromsetLength(intde);
tomromsetBreadth(intb);
intområde();
};
klasse Cube_Class:offentlig Rectangle_Class
{
privat:
inthøyde;
offentlig:
Cube_Class(inth)
{
høyde=h;
}
intgetHeight()
{
komme tilbakehøyde;
}
tomromsetHeight(inth)
{
høyde=h;
}
intvolum()
{
komme tilbakegetLength()*getBreadth()*høyde;
}
};
Rectangle_Class::Rectangle_Class()
{
lengde=1;
bredde=1;
}
Rectangle_Class::Rectangle_Class(intde,intb)
{
lengde=de;
bredde=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
lengde=r.lengde;
bredde=r.bredde;
}
tomromRectangle_Class::setLength(intde)
{
lengde=de;
}
tomromRectangle_Class::setBreadth(intb)
{
bredde=b;
}
intRectangle_Class::område()
{
komme tilbakelengde*bredde;
}
inthoved-()
{
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
koste<<'Volum er'<<c.volum()<<endl;
}
Konklusjon:
I denne artikkelen har jeg forklart begrepet arv i C ++ . C ++ støtter forskjellige typer arv, inkludert flere arv (dvs. arvelige funksjoner fra flere baseklasser eller foreldreklasser). For å gjøre det enklere har jeg imidlertid bare vurdert enkelt arv her. Jeg har vist tre arbeidseksempler for å forklare hvordan vi kan bruke arv i C ++-programmering og bruke koden på nytt. Dessuten er dette en veldig nyttig funksjon i C ++.