Bevezetés a túlterheléshez és a C ++ felülbírálásához

Kezdjük ezzel a C ++ túlterhelés és felülbírálás alapvető meghatározásaival.

Túlterhelés : A funkció neve azonos, de a paraméterek és a visszatérő típus megváltozik. Mivel megismerjük a különbséget a túlterhelt függvények között a fordítási idő alatt, ezt Compile idő polimorfizmusnak is nevezzük.

Felülíró: Ez az objektum-orientált programozási nyelv olyan tulajdonsága, ahol a gyermekosztály neve megegyezik a szülő osztályfunkciójának nevével. Mivel a felülíró funkciók a képre kerülnek, amikor az objektum deklarálva van, és a funkciókhoz az objektumok segítségével férnek hozzá; vagyis a kód végrehajtása során ezt a felülírási fogalmat futási idő polimorfizmusnak is nevezik.

A szintaxist és a programozási módszereket a későbbi szakaszokban ismertetjük.

A túlterhelés és az felülbírálás szintaxisa

Az alábbiakban bemutatjuk a túlterhelés és felülbírálás szintaxisát.

Szintaxis túlterhelése:

return_type function_name ( int param_1, string param_2)
(
//function definition
)
return_type_2 function_name ( int param_1, string param_2)
(
//function definition
)
return_type function_name ( int param_1, int param_2)
(
//function definition
)

Mindhárom együtt példát képezhet a túlterhelés koncepciójára.

A felülíró szintaxis:

Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);Class B : Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);

A fenti szintaxis a legfontosabb funkciók számára. A fő kimenet akkor következtethető le, amikor egy objektumot deklarálunk, és ugyanazokat az eljárásokat hívjuk meg az A és B osztályból. Az „Objektum” felülbírálásának funkciójában fontos szerepet játszik.

Nézzünk meg egy példát mindegyikre, hogy jobban megismerjék működésüket.

Példák a C ++ túlterhelésére és felülbírálására

Íme néhány példa a túlterhelésre és a C ++ felülbírálására az alábbiak szerint:

1. példa - Túlterhelés

Kezdjük egy egyszerű programmal.

Kód:

#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)
#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)
#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)

Kimenet:

Mi van, ha rossz adattípus értékeket adok az a, b változókra?

Kód:

int main()
(
int a = 10.8;
float b = 12;
calc(a);
calc(b);
calc(a, b);
)

Csak a fenti részt változtattam meg a fenti programtól, tehát itt van a kimenet.

Kimenet:

Kimenetet ad nekünk, mivel átalakítja az úszó értékét int adattípusra, és megadja a kimenetet.

Most gyakorlatként megpróbálhatja megváltoztatni a funkció visszatérési típusát és paramétereit, és játszani velük.

2. példa - felülbírálás

Az alábbiakban példát találhatunk a C ++ felülbíráló funkcióira.

Kód:

#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)

Kimenet:

A fenti kód segítségével megállapíthatjuk, hogy amikor az első osztályú objektum hivatkozását hozzárendeljük a második osztályunkhoz képest létrehozott objektumhoz. És akkor, amikor az alaposztály objektumának használatával jutottunk a felülbíráló módszerhez, egyértelműen észrevehetjük, hogy a származtatott osztálykimenet megjelenik. Ezt a fogalmat felülírónak nevezik. Az első és a második osztály az alap és a származtatott osztály. A fentiek kimenete a következő:

Gyakorlatként megpróbálhatja felülbírálni és túlterhelni egy funkciót, és ellenőrizheti, hogy lehetséges-e, vagy ellenőrizze, hogy a kimenet milyennek bizonyul?

Hogyan működik?

Túlterhelés: Itt nincs különös pont, amelyről tudomásul vesszük. Gondoskodnunk kell arról, hogy a visszatérés típusa vagy a függvény paraméterei eltérőek legyenek. Ha fent nézünk a programozási struktúrára, akkor a funkciókat deklaráljuk először, és megadjuk azok végrehajtását.

Fontos : Az öröklés szintaxisa és a funkciók végrehajtása a kulcsfontosságú pontok, amelyeket itt észre kell venni. A fenti példában észrevehetjük, hogy a funkció deklarálása a nyilvános kulcsszóval egészen más.

És a C ++ osztályban az osztálydefiníció egy pontosvesszővel (;) fejeződik be, és ha az alaposztályt örökölnünk kell a gyermekosztálynak, akkor a kettőspontot (:) kell használni. A felülírás fő funkcionalitása akkor figyelhető meg, amikor az objektumokat deklarálják és inicializálják az osztályhoz. Az objektumokkal történő függvényhívás után világosan megérthetjük a felülbírálás fogalmát.

Előnyök

  • Ezen felülírás és a túlterhelés egyik fő előnye az időmegtakarítás.
  • Takarítson meg memóriahelyet.
  • Növekszik a kód olvashatósága.
  • Itt a függvénytúlterhelés fogalmához különböző műveletekhez ugyanazokat a funkcióneveket használhatjuk, kiküszöbölve a különböző funkciónevek használatát.
  • A kód rugalmassága és karbantarthatósága könnyebbé válik.
  • Felülírás esetén a gyermekosztálynak lehetnek szülõosztályának funkciói, és akár saját maga is végrehajthatja ezt a funkciót.
  • Az objektumok hivatkozhatók, és mind a szülői osztály, mind a gyermekosztály funkciói elérhetők a gyermekosztályon.

Következtetés

Most egyértelműen megértettük a túlterhelés és a felülbírálás fogalmát. A túlterhelés során meg kell győződnünk arról, hogy a túlterhelt funkciókban a különbség létezik-e vagy a visszatérés típusa, vagy a paraméterek alapján, bár a benne található funkciódefiníció azonos vagy eltérő.

És felülbírálás esetén, mivel ez objektum-orientált programozási koncepció, csak osztályok formájában használhatjuk fel az öröklés funkcionalitását felhasználva.

Ajánlott cikkek

Ez egy útmutató a C ++ túlterheléshez és felülbíráláshoz. Itt tárgyaljuk a bevezetést, hogyan működik, a szintaxist, a példákat és a C ++ túlterhelés és felülbírálás előnyeit a kód megvalósításával. A következő cikkeket is megnézheti további információkért -

  1. Túlterhelés a C ++ kategóriában
  2. Túlterhelés vs felülbírálás
  3. A PHP felülbírálása
  4. A C ++ felülbírálása
  5. A Java alapon érvényes
  6. Polimorfizmus a Java-ban
  7. A C ++ 11 legfontosabb tulajdonságai és előnyei
  8. A Python felülbírálása | Funkció és szabályok

Kategória: