Beste Antwort
Tatsächlich gibt es in C kein Konzept für Polymorphismus. Polymorphismus ist eine Eigenschaft der objektorientierten Programmierung. Da C kein OOP ist, hat C kein Konzept für Polymorphismus. Während C ++ hat, da es eine objektorientierte Programmiersprache ist (nicht vollständig).
Polymorphismus bedeutet, viele Formen zu haben. In C ++ gibt es hauptsächlich zwei Arten von Polymorphsim:
- Kompilierungszeitpolymorphismus
- Laufzeitpolymorphismus
- Kompilierungszeitpolymorphismus : Diese Art von Polymorphismus wird durch Funktionsüberladung oder Operatorüberladung erreicht.
- Funktionsüberladung : Wenn mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parametern vorhanden sind, werden diese Funktionen als überladen bezeichnet. Funktionen können durch Änderung der Anzahl der Argumente oder / und Änderung der Art der Argumente überladen werden .
#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;
}
- Überladen von Operatoren: C ++ bietet auch die Option zum Überladen von Operatoren. Zum Beispiel können wir den Operator ("+") für die Zeichenfolgenklasse so einstellen, dass zwei Zeichenfolgen verkettet werden. Wir wissen, dass dies der Additionsoperator ist, dessen Aufgabe es ist, Operanden hinzuzufügen. Ein einzelner Operator +, der zwischen ganzzahligen Operanden platziert wird, fügt sie hinzu und verkettet sie, wenn er zwischen Zeichenfolgenoperanden platziert wird.
#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. Laufzeitpolymorphismus: : Diese Art von Polymorphismus wird durch Funktionsüberschreibung erreicht.
- Funktionsüberschreibung: tritt dagegen auf, wenn eine abgeleitete Klasse eine Definition für eine der Elementfunktionen der Basisklasse hat. Diese Basisfunktion soll überschrieben werden.
#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;
}
Antwort
Weil das die Definition von Polymorphismus ist: Der Code tut es nicht. Ich weiß bis zur Laufzeit nicht, was die tatsächliche Klasse eines Objekts ist.
Betrachten wir anhand eines herkömmlichen Beispiels eine Basisklasse Shape mit einer draw () -Methode. Die Form hat zwei Unterklassen: Kreis und Quadrat, die beide draw () überschreiben, um - Sie haben es erraten - einen Kreis bzw. ein Quadrat zu zeichnen.
Jetzt kann der Benutzer mit der Anwendung mehrere Formen erstellen. Die Ansichtsaktualisierungsfunktion durchläuft sie und ruft Folgendes auf:
currentShape.draw ()
Der Compiler kann zur Kompilierungszeit nicht feststellen, ob currentShape ein Quadrat oder ein Kreis ist also welche draw () Implementierung aufrufen soll. Die Entscheidung muss zur Laufzeit getroffen werden.
Zugegeben, es gibt Fälle, in denen der Compiler auf die tatsächliche Klasse eines Objekts * schließen * kann. In diesem Fall wird möglicherweise die Laufzeitsuche optimiert.
Beachten Sie, dass Polymorphismus und diese Laufzeit abhängig vom tatsächlichen Datentyp einer (oder mehrerer) ihrer Funktionen zur korrekten Implementierung einer Funktion führen Argumente sind sehr nützlich und mächtig.