Menú

Polimorfisme en C ++

polymorphism c

Proveu El Nostre Instrument Per Eliminar Problemes

Paper del polimorfisme en C ++ amb exemples.

El polimorfisme és un dels quatre pilars de la programació orientada a objectes. El polimorfisme significa tenir moltes formes. Es pot definir com la tècnica per la qual un objecte pot adoptar moltes formes segons la situació.

En termes de programació, podem dir que un objecte es pot comportar de manera diferent en diferents condicions.

En aquest tutorial, coneixerem els tipus de polimorfisme, les maneres d’implementar-lo juntament amb els altres conceptes de polimorfisme en detall.

=> Consulteu aquí per veure els tutorials de formació A-Z de C ++ aquí.

Polimorfisme en C ++

Per exemple, una dona pot assumir molts rols en diferents situacions. Per a un nen, és mare, mestressa de casa a casa, treballadora al despatx, etc. Per tant, una dona assumeix diferents rols i presenta un comportament diferent en diferents condicions. Aquest és un exemple real de polimorfisme.

De manera similar, també en el món de la programació, podem tenir un operador '+' que és l'operador d'addició binària que es comporta de manera diferent quan els operands canvien. Per exemple, quan els dos operands són numèrics, realitza una suma.

D'altra banda, quan els operands són una cadena, actua com a operador de concatenació. Així, el polimorfisme, en poques paraules, significa una entitat que adopta moltes formes o que es comporta de manera diferent en diferents condicions.

Què aprendreu:

Tipus de polimorfisme

El polimorfisme es divideix en dos tipus.

  • Compilar polimorfisme de temps
  • Polimorfisme en temps d'execució

El diagrama per representar-ho es mostra a continuació:

Tipus de polimorfisme

Com es mostra al diagrama anterior, el polimorfisme es divideix en polimorfisme en temps de compilació i polimorfisme en temps d'execució. El polimorfisme de temps de compilació es divideix a més en la sobrecàrrega de l’operador i la sobrecàrrega de funcions. El polimorfisme en temps d'execució s'implementa a més mitjançant funcions virtuals.

com crear un domini de correu electrònic fals

El polimorfisme de temps de compilació també es coneix com a polimorfisme estàtic o d’unió primerenca. En aquest tipus de polimorfisme, s’invoca el mètode de l’objecte en el moment de la compilació. En el cas del polimorfisme en temps d’execució, el mètode de l’objecte s’invoca en temps d’execució.

El polimorfisme en temps d'execució també es coneix com a unió dinàmica o tardana o polimorfisme dinàmic. Analitzarem la implementació detallada de cadascuna d’aquestes tècniques en els nostres temes següents.

Compila el polimorfisme de temps vs. Polimorfisme en temps d'execució

Vegem a continuació les principals diferències entre el temps de compilació i el polimorfisme en temps d'execució.

Compilar polimorfisme de tempsPolimorfisme en temps d'execució
També conegut com a polimorfisme estàtic o unió primerencaTambé conegut com a polimorfisme dinàmic o unió tardana / dinàmica
El mètode Objectes s’invoca en el moment de la compilacióEl mètode de l’objecte s’invoca en temps d’execució
Normalment s’implementa mitjançant la sobrecàrrega de l’operador i la sobrecàrrega de funcionsImplementat mitjançant funcions virtuals i substitució de mètodes
La sobrecàrrega de mètodes és un polimorfisme en temps de compilació en el qual més d’un mètode pot tenir el mateix nom, però diferents tipus de llista de paràmetres.La substitució del mètode és un polimorfisme en temps d'execució on més d'un mètode té el mateix nom amb el mateix prototip
Com que es coneixen mètodes en el moment de la compilació, l'execució és més ràpidaL'execució és més lenta, ja que el mètode es coneix en temps d'execució
Proporcioneu menys flexibilitat per implementar solucions, ja que cal saber-ho tot en el moment de la compilacióMolt més flexible per implementar solucions complexes ja que els mètodes es decideixen en temps d'execució

Compilar polimorfisme de temps

El polimorfisme de temps de compilació és una tècnica en què s’invoca el mètode d’un objecte en el moment de la compilació.

Aquest tipus de polimorfisme s’implementa de dues maneres.

  • Funció de sobrecàrrega
  • Sobrecàrrega de l'operador

Analitzarem detalladament cada tècnica.

Funció de sobrecàrrega

Es diu que una funció està sobrecarregada quan tenim més d’una funció amb el mateix nom però diferents tipus de paràmetres o un nombre diferent d’arguments.

Així, es pot sobrecarregar una funció en funció dels tipus de paràmetres, l’ordre dels paràmetres i el nombre de paràmetres.

Tingueu en compte que dues funcions que tenen el mateix nom i la mateixa llista de paràmetres però que tenen un tipus de retorn diferent no són una funció sobrecarregada i donaran lloc a un error de compilació si s’utilitza al programa.

De la mateixa manera, quan els paràmetres de la funció només difereixen en el punter i si el tipus de matriu és equivalent, no s’hauria d’utilitzar per sobrecarregar.

Altres tipus, com estàtics i no estàtics, constants i volàtils, etc. O les declaracions de paràmetres que difereixen en presència o en absència de valors predeterminats tampoc no s’utilitzaran per a la sobrecàrrega, ja que són equivalents des del punt de vista de la implementació.

Per exemple,els prototips de funció següents són funcions sobrecarregades.

Add(int,int); Add(int,float); Add(float,int); Add(int,int,int);

Als prototips anteriors, veiem que sobrecarreguem la funció Add en funció del tipus de paràmetres, la seqüència o l’ordre dels paràmetres, el nombre de paràmetres, etc.

Prenem un exemple complet de programació per entendre millor la sobrecàrrega de funcions.

#include #include using namespace std; class Summation { public: int Add(int num1,int num2) { return num1+num2; } int Add(int num1,int num2, int num3) { return num1+num2+num3; } string Add(string s1,string s2){ return s1+s2; } }; int main(void) { Summation obj; cout<

Sortida:

35
191
19
Hola món

Al programa anterior, tenim una classe Summation que defineix tres funcions sobrecarregades anomenades Add que prenen dos arguments enters, tres arguments enters i dos arguments de cadena.

A la funció principal, fem quatre trucades de funció que proporcionen diversos paràmetres. Les dues primeres trucades de funció són senzilles. A la tercera crida de funció a Add, proporcionem dos valors de coma flotant com a arguments.

En aquest cas, la funció que es fa coincidir és int Add (int, int) ja que internament, el float es converteix en doble i després es fa coincidir amb la funció amb els paràmetres int. Si haguéssim especificat double en lloc de float, tindríem una altra funció sobrecarregada amb double com a paràmetres.

La darrera trucada de funció utilitza valors de cadena com a paràmetres. En aquest cas, l’operador Add (+) actua com un operador de concatenació i concatena els dos valors de cadena per produir una sola cadena.

Avantatges de la sobrecàrrega de funcions

El principal avantatge de la sobrecàrrega de funcions és que afavoreix la reutilització del codi. Podem tenir tantes funcions com sigui possible amb el mateix nom sempre que es sobrecarreguin en funció del tipus d’argument, la seqüència d’arguments i el nombre d’arguments.

En fer-ho, es fa més fàcil tenir diferents funcions amb el mateix nom per representar el comportament de la mateixa operació en diferents condicions.

Si no hi hagués una sobrecàrrega de funcions, hauríem d’escriure massa tipus de funcions diferents amb noms diferents, fent així que el codi fos llegible i difícil d’adaptar.

Sobrecàrrega de l’operador

La sobrecàrrega de l’operador és la tècnica amb la qual donem un significat diferent als operadors existents en C ++. En altres paraules, sobrecarreguem els operadors per donar un significat especial als tipus de dades definits per l'usuari com a objectes.

La majoria dels operadors de C ++ tenen una sobrecàrrega o se’ls dóna un significat especial perquè puguin treballar en tipus de dades definits per l’usuari. Tingueu en compte que, mentre es fa una sobrecàrrega, el funcionament bàsic dels operadors no s’altera. La sobrecàrrega només proporciona a l’operador un significat addicional mantenint la mateixa semàntica bàsica.

Tot i que la majoria dels operadors es poden sobrecarregar en C ++, hi ha alguns operadors que no es poden sobrecarregar.

Aquests operadors es mostren a la taula següent.

Operadors
Operador de resolució d'abast (: :)
Mida de
selector de membres (.)
selector de punter de membre (*)
operador ternari (? :)

Les funcions que fem servir per sobrecarregar els operadors s’anomenen “ Funcions de l'operador '.

Les funcions de l'operador són similars a les funcions normals, però amb una diferència. La diferència és que el nom de les funcions de l’operador comença per la paraula clau “ operador ”Seguit del símbol de l’operador que s’ha de sobrecarregar.

A continuació, es crida la funció d'operador quan s'utilitza l'operador corresponent al programa. Aquestes funcions d'operador poden ser les funcions membres o mètodes globals o fins i tot una funció amiga.

La sintaxi general de la funció d'operador és:

return_type classname::operator op(parameter list) { //function body }

Aquí “operador op” és la funció de l’operador on l’operador és la paraula clau i op és l’operador que s’ha de sobrecarregar. Return_type és el tipus de valor a retornar.

Vegem pocs exemples de programació per demostrar la sobrecàrrega de l'operador mitjançant les funcions de l'operador.

Exemple 1:Sobrecàrrega de l’operador unari mitjançant la funció d’operador membre.

#include using namespace std; class Distance { public: int feet; // Constructor to initialize the object's value Distance(int feet) { this->feet = feet; } //operator function to overload ++ operator to perform increment on Distance obj void operator++() { feet++; } void print(){ cout << ' Incremented Feet value: ' << feet; } }; int main() { Distance d1(9); // Use (++) unary operator ++d1; d1.print(); return 0; }

Sortida:

Valor dels peus augmentat: 10

millors llocs d'anime per veure l'anime

Aquí hem sobrecarregat l’operador d’increment unari mitjançant la funció operator ++. A la funció principal, fem servir aquest operador ++ per incrementar l'objecte de la classe Distància.

Exemple 2:Sobrecàrrega de l’operador binari mitjançant la funció d’operador membre.

#include using namespace std; class Complex { int real, imag; public: Complex(int r = 0, int i =0) {real = r; imag = i;} //Operator function to overload binary + to add two complex numbers Complex operator + (Complex const &obj) { Complex c3; c3.real = real + obj.real; c3.imag = imag + obj.imag; return c3; } void print() { cout << real << ' + i' << imag << endl; } }; int main() { Complex c1(2, 5), c2(3, 7); cout<<'c1 = '; c1.print(); cout<<'c2 = '; c2.print(); cout<<'c3 = c1+c2 = '; Complex c3 = c1 + c2; // calls overloaded + operator c3.print(); }

Sortida:

c1 = 2 + i5
c2 = 3 + i7
c3 = c1 + c2 = 5 + i12

Aquí hem utilitzat l'exemple clàssic de l'addició de dos nombres complexos mitjançant la sobrecàrrega de l'operador. Definim una classe per representar nombres complexos i una funció d'operador per sobrecarregar + operador en la qual afegim les parts reals i imaginàries dels nombres complexos.

A la funció principal, declarem dos objectes complexos i els afegim mitjançant l'operador sobrecarregat + per obtenir el resultat desitjat.

A l'exemple següent, utilitzarem la funció amic per afegir dos nombres complexos per veure la diferència en la implementació.

#include using namespace std; class Complex { int real, imag; public: Complex(int r = 0, int i =0) {real = r; imag = i;} //friend function to overload binary + to add two complex numbers friend Complex operator +(Complex const &, Complex const &); void print() { cout << real << ' + i' << imag << endl; } }; Complex operator + (Complex const &c1, Complex const &c2) { Complex c3; c3.real = c1.real + c2.real; c3.imag = c1.imag + c2.imag; return c3; } int main() { Complex c1(2, 5), c2(3, 7); cout<<'c1 = '; c1.print(); cout<<'c2 = '; c2.print(); cout<<'c3 = c1+c2 = '; Complex c3 = c1 + c2; // calls overloaded + operator c3.print(); }

Sortida:

c1 = 2 + i5
c2 = 3 + i7
c3 = c1 + c2 = 5 + i12

Veiem que la sortida del programa és la mateixa. L'única diferència en la implementació és l'ús de la funció friend per sobrecarregar l'operador + en lloc d'una funció membre en la implementació anterior.

Quan s'utilitza la funció amic per a un operador binari, hem d'especificar explícitament els operands de la funció. De la mateixa manera, quan l'operador unari està sobrecarregat mitjançant la funció friend, hem de proporcionar l'operant únic a la funció.

A part de les funcions de l’operador, també podem escriure un operador de conversió que s'utilitza per convertir d'un tipus a un altre. Aquests operadors de conversió sobrecarregats haurien de ser una funció membre de la classe.

Exemple 3:Sobrecàrrega de l’operador mitjançant l’operador de conversió.

#include using namespace std; class DecFraction { int numerator, denom; public: DecFraction(int num, int denm) { numerator = num; denom = denm; } // conversion operator: converts fraction to float value and returns it operator float() const { return float(numerator) / float(denom); } }; int main() { DecFraction df(3, 5); //object of class float res_val = df; //calls conversion operator cout << 'The resultant value of given fraction (3,5)= '<

Sortida:

El valor resultant de la fracció donada (3,5) = 0,6

En aquest programa, hem utilitzat l'operador de conversió per convertir la fracció donada en un valor flotant. Un cop feta la conversió, l'operador de conversió retorna el valor resultant a la persona que truca.

A la funció principal, quan assignem l'objecte df a una variable res_val, la conversió té lloc i el resultat s'emmagatzema a res_val.

També podem anomenar un constructor amb un únic argument. Quan podem trucar a un constructor de la classe mitjançant un únic argument, això s’anomena “ conversió constructor ”. El constructor de conversions es pot utilitzar per a la conversió implícita a la classe que s'està construint.

#include using namespace std; class Point { private: int x,y; public: Point(int i=0,int j=0) {x = i;y=j;} void print() { cout<<' x = '<

Sortida:

Punt construït mitjançant un constructor normal
x = 20 i = 30
Punt construït mitjançant un constructor de conversió
x = 10 i = 0

Sortida de sobrecàrrega d

Aquí tenim una classe Point que defineix un constructor amb valors per defecte. A la funció principal, construïm un objecte pt amb coordenades x i y. A continuació, acabem d’assignar a pt un valor de 10. Aquí s’anomena el constructor de conversions i a x se li assigna un valor de 10 mentre que a y se li dóna el valor per defecte de 0.

Regles de sobrecàrrega de l’operador

Mentre realitzem la sobrecàrrega de l’operador, hem de vigilar les regles següents.

  • A C ++, només podem sobrecarregar els operadors existents. Els operadors afegits recentment no es poden sobrecarregar.
  • Quan els operadors estan sobrecarregats, hem d’assegurar-nos que almenys un dels operands sigui del tipus definit per l’usuari.
  • Per sobrecarregar alguns operadors, també podem fer ús de la funció amic.
  • Quan sobrecarreguem operadors unaris que fan servir una funció membre, no necessita cap argument explícit. Es necessita un argument explícit quan l'operador unari està sobrecarregat mitjançant la funció friend.
  • De la mateixa manera, quan els operadors binaris es sobrecarreguen mitjançant la funció membre, hem de proporcionar un argument explícit a la funció. Quan els operadors binaris es sobrecarreguen mitjançant la funció friend, la funció adopta dos arguments.
  • Hi ha dos operadors a C ++ que ja estan sobrecarregats. Aquests són '=' i '&'. Per tant, per copiar un objecte de la mateixa classe, no necessitem sobrecarregar l’operador = i el podem utilitzar directament.

Avantatges de la sobrecàrrega de l’operador

La sobrecàrrega de l'operador en C ++ ens permet ampliar la funcionalitat dels operadors als tipus definits per l'usuari, inclosos els objectes de classe, a més dels tipus integrats.

En estendre la funcionalitat de l’operador als tipus definits per l’usuari, no necessitem escriure codi complex per realitzar diverses operacions en tipus definits per l’usuari, sinó que ho podem fer en una mateixa operació, igual que els tipus integrats.

Conclusió

El polimorfisme de temps de compilació proporciona una facilitat de sobrecàrrega principalment per ampliar la funcionalitat del codi en termes de sobrecàrrega de funcions i sobrecàrrega de l’operador.

Mitjançant la sobrecàrrega de funcions, podem escriure més d’una funció amb el mateix nom però diferents paràmetres i tipus. Això fa que el codi sigui senzill i fàcil de llegir. Mitjançant la sobrecàrrega de l’operador, podem ampliar la funcionalitat dels operadors, de manera que també podem fer operacions bàsiques en tipus definits per l’usuari.

Al nostre proper tutorial, aprendrem més sobre el polimorfisme en temps d'execució en C ++.

=> Llegiu la sèrie de formació Easy C ++.

Lectura recomanada

^