Wat wordt bedoeld met polymorfisme in C?


Beste antwoord

Eigenlijk is er geen concept van polymorfisme in C. Polymorfisme is een eigenschap van Object Oriented Programming. Omdat C geen OOP is, heeft C geen concept van polymorfisme. Terwijl C ++ dat wel heeft, aangezien het een objectgeoriënteerde programmeertaal is (niet volledig).

Polymorfisme betekent dat het vele vormen heeft. Er zijn hoofdzakelijk twee soorten polymorfsim in C ++:

  • Compilatietijd polymorfisme
  • Runtime polymorfisme
    1. Compilatietijdpolymorfisme : dit type polymorfisme wordt bereikt door overbelasting van functies of overbelasting van operators.
  • Functieoverbelasting : Als er meerdere functies zijn met dezelfde naam maar verschillende parameters, dan wordt gezegd dat deze functies overbelast zijn. Functies kunnen worden overbelast door wijziging in het aantal argumenten of / en wijziging in type argumenten .

#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;

}

  • Overbelasting operator: C ++ biedt ook een optie om operators te overbelasten. We kunnen bijvoorbeeld de operator (‘+’) voor stringklasse maken om twee strings samen te voegen. We weten dat dit de opteloperator is wiens taak het is om toe te voegen aan operanden. Dus een enkele operator + wanneer geplaatst tussen integer operanden, voegt ze toe en wanneer geplaatst tussen string operanden, voegt ze samen.

#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. Runtime-polymorfisme: : dit type polymorfisme wordt bereikt door functie-overschrijving.

  • Functie overschrijven: treedt daarentegen op wanneer een afgeleide klasse een definitie heeft voor een van de lidfuncties van de basisklasse. Die basisfunctie zou worden overschreven.

#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;

}

Antwoord

Omdat dat de definitie van polymorfisme is: de code doet niet t weet tot runtime wat de feitelijke klasse van een object is.

Laten we met een traditioneel voorbeeld een basisklasse Shape beschouwen met een draw () - methode. Vorm heeft twee subklassen: Cirkel en Vierkant die beide draw () overschrijven om - je raadt het al - respectievelijk een cirkel en een vierkant te tekenen.

Nu laat de toepassing de gebruiker verschillende vormen maken. En de view-updatefunctie itereert erover en roept:

currentShape.draw ()

de compiler kan tijdens het compileren niet weten of currentShape een vierkant of een cirkel zal zijn en dus welke draw () implementatie te bellen. De beslissing moet tijdens runtime worden genomen.

Toegegeven, er zijn gevallen waarin de compiler * de werkelijke klasse van een object kan * afleiden. In dat geval zal het mogelijk de runtime-look-up optimaliseren.

Merk op dat polymorfisme en deze runtime-verzending naar de juiste implementatie van een functie leiden, afhankelijk van het feitelijke gegevenstype van een (of meer) van zijn argumenten zijn erg nuttig en krachtig.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *