Was ist unter Polymorphismus in C zu verstehen?


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
    1. 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.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.