C ++ és un d’aquests llenguatges de programació que és molt flexible i que també cobreix diverses característiques de la programació orientada a objectes. La sobrecàrrega és una altra característica d’aquest llenguatge de programació.Els següents indicadors es tractaran en aquest article de 'Sobrecàrrega de funcions en C ++'
- C ++ sobrecàrrega
- Tipus de sobrecàrrega en C ++
- Què és la sobrecàrrega de funcions a C ++
- Canviant el nombre d’arguments
- En tenir diferents tipus d’arguments
- Avantatges de la sobrecàrrega de funcions en C ++
- Desavantatges de la sobrecàrrega de funcions en C ++
- Funció de sobrecàrrega i ambigüitat
C ++ sobrecàrrega
Quan creem dos o més membres d’una classe que tenen el mateix nom però diferents en nombre o tipus de paràmetres, es coneix com a sobrecàrrega C ++. A C ++, podem sobrecarregar:
- mètodes,
- constructors, i
- propietats indexades
Tipus de sobrecàrrega en C ++
Què és la sobrecàrrega de funcions a C ++?
La sobrecàrrega de funcions a C ++ es pot definir com el procés de tenir dues o més funcions membres d'una classe amb el mateix nom, però diferents en paràmetres. En la sobrecàrrega de funcions, la funció es pot redefinir utilitzant diferents tipus d'arguments o un nombre diferent d'arguments segons el requisit. És només mitjançant aquestes diferències que el compilador pot diferenciar entre les dues funcions sobrecarregades.
Un dels avantatges principals de la sobrecàrrega de funcions és que augmenta la llegibilitat del programa perquè no necessitem utilitzar noms diferents per a la mateixa acció una i altra vegada.
revers d'un número en java
Canviant el nombre d’arguments
En aquesta forma de sobrecàrrega de funcions, definim dues funcions amb els mateixos noms però un nombre diferent de paràmetres del mateix tipus. Per exemple, al programa esmentat a continuació, hem fet dues funcions add () per retornar la suma de dos i tres enters.
// primera funció definició int afegir (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }Aquí es diu que la funció add () està sobrecarregada, ja que té dues definicions, una que accepta dos arguments i una altra que accepta tres arguments. La funció add () que es cridarà dependrà del nombre d'arguments.
int main () {add (10, 20) // add () amb 2 paràmetres es dirà add (10, 20, 30) // sum () amb 3 paràmetres es dirà}#include using namespace std int add (int a, int b) {cout<< a+b <A l'exemple anterior, sobrecarregem la funció add () canviant el nombre d'arguments. Primer, definim una funció add () amb dos paràmetres, després la sobrecarreguem definint de nou la funció add (), però aquesta vegada amb tres paràmetres.
En tenir diferents tipus d’arguments
En aquest mètode, definim dues o més funcions amb el mateix nom i el mateix nombre de paràmetres, però el tipus de dades utilitzat per a aquests paràmetres és diferent. Per exemple, en aquest programa, tenim tres funcions add (), el primer obté dos arguments enters, el segon obté dos arguments flotants i el tercer obté dos arguments dobles.
#include using namespace std int add (int x, int y) // primera definició {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }A l'exemple anterior, definim la funció add () tres vegades. Primer fent servir enters com a paràmetres, segon fent servir float com a paràmetres i tercer fent servir el doble com a paràmetre.
Per tant, substituïm la funció add () dues vegades.
Avantatges de la funció Sobrecàrrega en C ++
Utilitzem la sobrecàrrega de funcions per estalviar espai de memòria, consistència i llegibilitat del nostre programa.
Amb el concepte de sobrecàrrega de la funció d’ús, podem desenvolupar més d’una funció amb el mateix nom
La sobrecàrrega de funcions mostra el comportament del polimorfisme que ens permet tenir un comportament diferent, tot i que hi haurà algun enllaç amb el mateix nom de la funció.
La sobrecàrrega de funcions agilitza l'execució del programa.
La sobrecàrrega de funcions s’utilitza per reutilitzar el codi i també per estalviar memòria.
Ajuda l’aplicació a carregar el mètode de classe en funció del tipus de paràmetre.
El manteniment del codi és fàcil.
Desavantatges de la funció Sobrecàrrega en C ++
- Les declaracions de funcions que difereixen només pel seu tipus de retorn no es poden sobrecarregar amb el procés de sobrecàrrega de funcions.
- Les declaracions de funcions de membre amb els mateixos paràmetres o els mateixos tipus de noms no es poden sobrecarregar si alguna d'elles es declara com a funció de membre estàtica.
classe XYZ {static void func () void func () // error}
Funció de sobrecàrrega i ambigüitat
Quan el compilador no pot decidir quina funció ha d’invocar primer entre les funcions sobrecarregades, aquesta situació es coneix com a ambigüitat de sobrecàrrega de funcions. El compilador no executa el programa si mostra un error d'ambigüitat. Causes de l'ambigüitat de sobrecàrrega de funcions:
- Conversió de tipus.
- Funció amb arguments predeterminats.
- Funció amb una passada per referència
Conversió de tipus:
#include using namespace std function void (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <L'exemple anterior genera un error: 'la trucada de la funció (doble) sobrecarregada és ambigua'. La funció (3.4) cridarà la primera funció. La funció (34) crida la segona funció segons la nostra predicció. Però no és el que passa perquè a C ++ totes les constants de coma flotant es tracten com a dobles, no com a flotants. Si substituïm la variable float per una variable doble, el programa funcionarà bé. Per tant, anomenem error de conversió de tipus flotant a doble.
Funció amb arguments predeterminats:
#include using namespace std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <L'exemple anterior mostra un error que diu que 'la trucada de' fun (int) 'sobrecarregada és ambigua', perquè la funció (int y, int z = 12) es pot cridar de dues maneres:
- Cridant la funció amb un argument (i automàticament prendrà el valor de z = 12)
- Cridant la funció amb dos arguments.
Quan anomenem la funció: funció (12), omplim completament la condició tant de la funció (int) com de la funció (int, int), de manera que el compilador entra en una ambigüitat que mostra un error.
Funció amb passada per referència
#include using namespace std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < El programa anterior mostra un error en dir que 'la trucada de' fun (int &) 'amb sobrecàrrega és ambigua'. Com veiem, la primera funció pren un argument enter i la segona funció pren un paràmetre de referència com a argument. En aquest cas, el compilador no és capaç d’entendre quina funció necessita l’usuari, ja que no hi ha diferències sintàctiques entre fun (int) i fun (int &), de manera que provoca un error d’ambigüitat.
Amb això, arribem al final d'aquesta sobrecàrrega de funcions en C ++. Si voleu obtenir més informació, consulteu el per Edureka, una empresa d’aprenentatge en línia de confiança. El curs de formació i certificació Java J2EE i SOA d’Edureka està dissenyat per formar-vos tant per a conceptes bàsics com avançats de Java, juntament amb diversos marcs Java com Hibernate & Spring
Tens alguna pregunta? Si us plau, mencioneu-lo a la secció de comentaris d’aquest bloc i us respondrem el més aviat possible.