Legjobb válasz
Valójában a C-ben nincs a polimorfizmus fogalma. A polimorfizmus az objektumorientált programozás tulajdonsága. Mivel a C nem OOP, C-nek nincs fogalma a polimorfizmusról. Míg a C ++ rendelkezik, mivel objektum-orientált programozási nyelv (nem teljesen).
A polimorfizmus azt jelenti, hogy sokféle formája van. A C ++ nyelven főként kétféle polimorfizmus létezik:
- Compile time Polymorphism
- Futásidejű polimorfizmus
- Kompilálási idő polimorfizmus : Ez a fajta polimorfizmus a funkció túlterhelésével vagy az operátor túlterhelésével érhető el. : Ha több függvény van ugyanazzal a névvel, de különböző paraméterekkel, akkor ezeket a függvényeket túlterheltnek mondják . A funkciókat túlterhelheti az argumentumok számának megváltoztatása vagy / és argumentumtípus megváltoztatása .
#include
using namespace std;
class Geeks
{
public:
// function with 1 int parameter
void func(int x)
{
cout << "value of x is " << x << endl;
}
// function with same name but 1 double parameter
void func(double x)
{
cout << "value of x is " << x << endl;
}
// function with same name and 2 int parameters
void func(int x, int y)
{
cout << "value of x and y is " << x << ", " << y << endl;
}
};
int main() {
Geeks obj1;
// The first "func" is called
obj1.func(7);
// The second "func" is called
obj1.func(9.132);
// The third "func" is called
obj1.func(85,64);
return 0;
}
- Operátor túlterhelése: A C ++ lehetőséget kínál az operátorok túlterhelésére is. Például elkészíthetjük a string osztály operátorát (’+’) két húr összefűzéséhez. Tudjuk, hogy ez az addíciós operátor, amelynek feladata az operandusok hozzáadása. Tehát egyetlen „+” operátor egész operandusok közé helyezve összeadja őket, és ha string-operandusok közé helyezi, összefűzi őket.
#include
using namespace std;
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i =0) {real = r; imag = i;}
// This is automatically called when "+" is used with
// between two Complex objects
Complex operator + (Complex const &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
void print() { cout << real << " + i" << imag << endl; }
};
int main()
{
Complex c1(10, 5), c2(2, 4);
Complex c3 = c1 + c2; // An example call to "operator+"
c3.print();
}
2. Futásidejű polimorfizmus: : Ez a fajta polimorfizmus a Funkció felülírása révén érhető el.
- Funkció felülbírálása: másrészt akkor fordul elő, ha egy származtatott osztály meghatározza az alaposztály egyik tagfüggvényét. Azt mondják, hogy ezt az alapfunkciót felülbírálják.
#include
using namespace std;
// Base class
class Parent
{
public:
void print()
{
cout << "The Parent print function was called" << endl;
}
};
// Derived class
class Child : public Parent
{
public:
// definition of a member function already present in Parent
void print()
{
cout << "The child print function was called" << endl;
}
};
//main function
int main()
{
//object of parent class
Parent obj1;
//object of child class
Child obj2 = Child();
// obj1 will call the print function in Parent
obj1.print();
// obj2 will override the print function in Parent
// and call the print function in Child
obj2.print();
return 0;
}
Válasz
Mivel ez a polimorfizmus meghatározása: a kód nem futásig nem tudom, hogy mi az egyes objektumok tényleges osztálya.
Hagyományos példát használva vizsgáljuk meg a Shape egy draw () metódussal egy alaposztályt. Az Alaknak két alosztálya van: a Kör és a Négyzet, amelyek felülírják a rajzolást (), hogy - kitaláltátok - egy kört és egy négyzetet rajzoljanak.
Most az alkalmazás lehetővé teszi a felhasználó számára, hogy több alakzatot hozzon létre. És a nézetfrissítési funkció iterál rajtuk és meghívja:
currentShape.draw ()
a fordító nem tudja tudni fordításkor, hogy a currentShape négyzet vagy kör lesz-e, és így amelyek felhívják a () megvalósítást. A döntést futás közben kell meghozni.
Igaz, vannak olyan esetek, amikor a fordító * következtetni tud egy objektum tényleges osztályára. Ebben az esetben ez optimalizálja a futásidejű keresést. érvek nagyon hasznosak és hatékonyak.