Supraîncărcarea funcției

Supraîncărcarea operațiunilor (operatori, funcții, proceduri)- în programare - una dintre modalitățile de implementare a polimorfismului, care constă în posibilitatea existenței simultane într-un singur domeniu a mai multor diverse opțiuni operațiuni (instrucțiune, funcție sau procedură) care au același nume, dar diferă prin tipurile de parametri cărora li se aplică.

Terminologie

Termenul „supraîncărcare” este o hârtie de calc a „supraîncărcării” engleză, care a apărut în traducerile ruse ale cărților despre limbaje de programare în prima jumătate a anilor 1990. Poate că acesta nu este cel mai mult cea mai bună opțiune traducere, deoarece cuvântul „supraîncărcare” în limba rusă are un înțeles propriu stabilit, radical diferit de cel recent propus, cu toate acestea, a prins rădăcini și este destul de răspândit. În publicațiile din epoca sovietică, mecanisme similare au fost numite în rusă „redefinirea” sau „redefinirea” operațiunilor, dar această opțiune nu este discutabilă: apar discrepanțe și confuzii în traducerile englezei „override”, „supraîncărcare” și „ redefiniți”.

Motivele apariției

Majoritatea limbajelor de programare timpurii aveau o restricție conform căreia nu mai mult de o operație cu același nume putea fi disponibilă într-un program în același timp. În consecință, toate funcțiile și procedurile vizibile la un punct dat în program trebuie să aibă nume diferite. Numele și denumirile funcțiilor, procedurilor și operatorilor care fac parte din limbajul de programare nu pot fi folosite de programator pentru a-și denumi propriile funcții, proceduri și operatori. În unele cazuri, un programator își poate crea propriul obiect program cu numele altuia deja existent, dar apoi obiectul nou creat se „suprapune” pe cel anterior și devine imposibil să folosești ambele opțiuni în același timp.

Această situație este incomodă în unele cazuri destul de frecvente.

• Uneori este nevoie de a descrie și de a aplica operațiuni la tipurile de date create de programator care sunt echivalente ca semnificație cu cele deja disponibile în limbaj. Un exemplu clasic este o bibliotecă pentru lucrul cu numere complexe. Ele, ca și tipurile numerice obișnuite, acceptă operații aritmetice și ar fi firesc să creați pentru de acest tip operațiile „plus”, „minus”, „înmulțire”, „împărțire”, notându-le cu aceleași semne de operație ca și pentru alte tipuri numerice. Interdicția utilizării elementelor definite în limbaj obligă la crearea multor funcții cu nume precum ComplexPlusComplex, IntegerPlusComplex, ComplexMinusFloat și așa mai departe.
• Când operanzilor se aplică operanzii de aceeași semnificație tipuri variate, ele trebuie denumite diferit. Incapacitatea de a aplica tipuri diferite funcțiile cu același nume duce la necesitatea de a inventa nume diferite pentru același lucru, ceea ce creează confuzie și poate duce la erori. De exemplu, în limbajul clasic C, există două versiuni ale funcției standard de bibliotecă pentru găsirea modulului unui număr: abs() și fabs() - prima este destinată unui argument întreg, a doua pentru unul real. Această situație, combinată cu verificarea slabă de tip C, poate duce la o eroare greu de găsit: dacă un programator scrie abs(x) în calcul, unde x este o variabilă reală, atunci unii compilatori vor genera cod fără avertisment care va convertiți x într-un număr întreg eliminând părțile fracționale și calculați modulul din întregul rezultat!

În parte, problema este rezolvată prin intermediul programării obiectelor - atunci când noi tipuri de date sunt declarate ca clase, operațiunile asupra acestora pot fi formalizate ca metode de clasă, inclusiv metode de clasă cu același nume (deoarece metodele din clase diferite nu trebuie să aibă nume diferite), dar, în primul rând, un astfel de mod de proiectare a operațiunilor pe valori de diferite tipuri este incomod și, în al doilea rând, nu rezolvă problema creării de noi operatori.

Supraîncărcarea operatorului în sine este doar „zahăr sintactic”, deși chiar și ca atare poate fi utilă deoarece permite dezvoltatorului să programeze într-un mod mai natural și face ca tipurile personalizate să se comporte mai mult ca cele încorporate. Dacă abordăm problema dintr-o poziție mai generală, atunci putem vedea că instrumentele care vă permit să extindeți limbajul îl completează cu noi operații și construcții sintactice (și supraîncărcarea operațiilor este unul dintre astfel de instrumente, alături de obiecte, macro-uri). , funcționale, închideri) îl transformă deja în metalimbaj - un mijloc de descriere a limbilor orientate către sarcini specifice. Cu ajutorul acestuia, este posibil să construiți o extensie de limbaj pentru fiecare sarcină specifică care este cea mai potrivită pentru aceasta, ceea ce va permite descrierea soluției sale în forma cea mai naturală, mai ușor de înțeles și mai simplă. De exemplu, într-o aplicație de supraîncărcare a operațiilor: crearea unei biblioteci de tipuri matematice complexe (vectori, matrice) și descrierea operațiilor cu acestea într-o formă naturală, „matematică”, creează un „limbaj pentru operații vectoriale”, în care complexitatea calculele este ascunsă și este posibil să se descrie soluția problemelor în termeni de operații vectoriale și matrice, concentrându-se pe esența problemei, nu pe tehnică. Din aceste motive, astfel de mijloace au fost odată incluse în limba Algol-68.

Mecanism de suprasarcină

Implementarea

Supraîncărcarea operatorului implică introducerea a două caracteristici interdependente în limbaj: capacitatea de a declara mai multe proceduri sau funcții cu același nume în același domeniu și capacitatea de a descrie propriile implementări ale operațiunilor (adică semnele operațiunilor, de obicei scris cu notație infixă, între operanzi). Practic, implementarea lor este destul de simplă:

• Pentru a permite existența mai multor operații cu același nume, este suficient să se introducă în limbaj o regulă, conform căreia o operație (procedură, funcție sau operator) este recunoscută de compilator nu numai după nume (notație), ci de asemenea prin tipurile parametrilor lor. Deci abs(i), unde i este declarat ca un întreg, și abs(x), unde x este declarat ca real, sunt două operații diferite. În principiu, nu există dificultăți în a oferi doar o astfel de interpretare.
• Pentru a permite operațiunile de definire și redefinire, este necesar să se introducă în limbaj construcții sintactice adecvate. Pot exista destul de multe opțiuni, dar de fapt nu diferă unele de altele, este suficient să ne amintim că introducerea formularului „<операнд1> <знакОперации> <операнд2>» este fundamental similar cu apelarea funcției «<знакОперации>(<операнд1>,<операнд2>)". Este suficient să permiteți programatorului să descrie comportamentul operatorilor sub formă de funcții - iar problema descrierii este rezolvată.

Opțiuni și probleme

Supraîncărcarea procedurilor și funcțiilor la nivel idee comună, de regulă, nu este greu nici de implementat, nici de înțeles. Cu toate acestea, chiar și în el există câteva „capcane” care trebuie luate în considerare. Permiterea supraîncărcării operatorului creează mult mai multe probleme atât pentru implementatorul limbajului, cât și pentru programatorul care lucrează în limba respectivă.

Problema de identificare

Prima întrebare cu care se confruntă un dezvoltator al unui traducător de limbi care permite supraîncărcarea procedurilor și funcțiilor este cum să aleagă dintre procedurile cu același nume pe cea care ar trebui aplicată într-un anumit caz concret? Totul este în regulă dacă există o variantă a procedurii, ale căror tipuri de parametri formali se potrivesc exact cu tipurile de parametrii efectivi utilizați în acest apel. Cu toate acestea, în aproape toate limbile, există un anumit grad de libertate în utilizarea tipurilor, presupunând că compilatorul realizează automat conversii sigure de tip în anumite situații. De exemplu, în operațiile aritmetice pe argumente reale și întregi, întregul este de obicei convertit automat în tip real, iar rezultatul este real. Să presupunem că există două variante ale funcției de adăugare:

int add(int a1, int a2); float add(float a1, float a2);

Cum ar trebui să gestioneze compilatorul expresia y = add(x, i) unde x este un float și i este un int? Evident, nu există o potrivire exactă. Există două opțiuni: fie y=add_int((int)x,i) , fie ca y=add_flt(x, (float)i) (aici numele add_int și add_float denotă prima și, respectiv, a doua versiune a funcției) .

Se pune întrebarea: compilatorul ar trebui să permită această utilizare a funcțiilor supraîncărcate și, dacă da, pe ce bază va alege varianta particulară utilizată? În special, în exemplul de mai sus, traducătorul ar trebui să ia în considerare tipul variabilei y atunci când alege? Trebuie remarcat faptul că situația de mai sus este cea mai simplă, sunt posibile cazuri mult mai complicate, care sunt agravate de faptul că nu numai tipurile încorporate pot fi convertite conform regulilor limbajului, ci și clasele declarate de programator. , dacă au relații de rudenie, pot fi aruncați unul la altul. Există două soluții la această problemă:

• Interziceți deloc identificarea incorectă. Solicitați ca pentru fiecare pereche particulară de tipuri să existe o variantă exactă potrivită a procedurii sau operațiunii supraîncărcate. Dacă nu există o astfel de opțiune, compilatorul ar trebui să arunce o eroare. În acest caz, programatorul trebuie să aplice o conversie explicită pentru a transforma parametrii actuali la setul de tipuri dorit. Această abordare este incomodă în limbaje precum C++, care permit o libertate destul de mare în tratarea tipurilor, deoarece duce la o diferență semnificativă în comportamentul operatorilor încorporați și supraîncărcați (operațiile aritmetice pot fi aplicate numerelor obișnuite fără a sta pe gânduri, ci la alte tipuri - numai cu conversie explicită) sau la apariția unui număr mare de opțiuni pentru operațiuni.
• Stabiliți anumite reguli pentru alegerea „cea mai apropiată potrivire”. De obicei, în această variantă, compilatorul le alege pe acelea dintre variantele ale căror apeluri pot fi obținute din sursă doar prin conversii de tip sigur (informații fără pierderi), iar dacă sunt mai multe, poate alege în funcție de care variantă necesită mai puține. astfel de conversii. Dacă rezultatul lasă mai multe posibilități, compilatorul aruncă o eroare și solicită programatorului să specifice în mod explicit varianta.

Considerații specifice privind supraîncărcarea operației

Spre deosebire de proceduri și funcții, operațiunile infixe ale limbajelor de programare au două proprietăți suplimentare care le afectează în mod semnificativ funcționalitatea: prioritatea și asociativitatea, a căror prezență se datorează posibilității de înregistrare „în lanț” a operatorilor (cum să înțelegem a + b * c: ca (a + b )*c sau ca a+(b*c) ? Expresia a-b+c este (a-b)+c sau a-(b+c) ?).

Operațiile încorporate în limbaj au întotdeauna precedență tradițională și asociativitate predefinite. Se pune întrebarea: ce priorități și asociativitate vor avea versiunile redefinite ale acestor operații sau, mai mult, noile operații create de programator? Există și alte subtilități care ar putea necesita clarificări. De exemplu, în C există două forme de operatori de creștere și decrementare ++ și -- - prefix și postfix, care se comportă diferit. Cum ar trebui să se comporte versiunile supraîncărcate ale unor astfel de operatori?

Diferite limbi abordează aceste probleme în moduri diferite. Astfel, în C++, precedența și asociativitatea versiunilor supraîncărcate ale operatorilor sunt păstrate aceleași cu cele definite în limbaj; este posibil să supraîncărcați separat formele de prefix și postfix ale operatorilor de creștere și decrementare folosind semnături speciale:

Deci int este folosit pentru a face diferența în semnături

Anunțul de noi operațiuni

Situația cu anunțul de noi operațiuni este și mai complicată. Includerea posibilității unei astfel de declarații în limbă nu este dificilă, dar implementarea acesteia este plină de dificultăți semnificative. Declararea unei noi operațiuni înseamnă, de fapt, crearea unei noi cuvânt cheie limbaj de programare, complicat de faptul că operațiunile din text, de regulă, pot urma fără separatori cu alte jetoane. Când apar, apar dificultăți suplimentare în organizarea analizatorului lexical. De exemplu, dacă limbajul are deja operațiile „+” și unara „-” (schimbarea semnului), atunci expresia a+-b poate fi interpretată cu precizie ca a + (-b), dar dacă o nouă operație +- este declarată în program, apare imediat ambiguitate, deoarece aceeași expresie poate fi deja analizată ca a (+-) b . Dezvoltatorul și implementatorul limbajului trebuie să se ocupe de astfel de probleme într-un fel. Opțiunile, din nou, pot fi diferite: necesită ca toate operațiunile noi să fie cu un singur caracter, postulează că, în cazul oricăror discrepanțe, se alege cea mai „lungă” versiune a operației (adică până la următorul set de caractere citit de către translator se potrivește cu orice operațiune, continuă să fie citit), încearcă să detecteze coliziuni în timpul traducerii și să genereze erori în cazuri controversate... Într-un fel sau altul, limbile care permit declararea de noi operațiuni rezolvă aceste probleme.

Nu trebuie uitat că pentru operațiuni noi se pune și problema determinării asociativității și priorității. Nu mai există o soluție gata făcută sub forma unei operațiuni de limbaj standard și, de obicei, trebuie doar să setați acești parametri cu regulile limbii. De exemplu, faceți toate operațiunile noi asociate stânga și acordați-le aceeași, fixă, prioritate sau introduceți în limbaj mijloacele de specificare a ambelor.

Supraîncărcare și variabile polimorfe

Când operatorii, funcțiile și procedurile supraîncărcate sunt utilizate în limbaje puternic tipizate, în care fiecare variabilă are un tip pre-declarat, este la latitudinea compilatorului să decidă ce versiune a operatorului supraîncărcat să folosească în fiecare caz particular, indiferent cât de complexă. . Aceasta înseamnă că pentru limbajele compilate, utilizarea supraîncărcării operatorului nu duce la degradarea performanței - în orice caz, există o operație sau un apel de funcție bine definit în codul obiect al programului. Situația este diferită atunci când este posibil să se utilizeze variabile polimorfe în limbaj, adică variabile care pot conține valori de diferite tipuri în momente diferite.

Deoarece tipul valorii la care se va aplica operația supraîncărcată nu este cunoscut în momentul traducerii codului, compilatorul nu poate alege opțiunea dorită anticipat. În acest caz, este forțat să încorporați un fragment în codul obiect care, imediat înainte de efectuarea acestei operațiuni, va determina tipurile de valori din argumente și va selecta dinamic o variantă corespunzătoare acestui set de tipuri. Mai mult, o astfel de definiție trebuie făcută la fiecare execuție a operației, deoarece chiar și același cod, fiind numit a doua oară, poate fi executat diferit.

Astfel, utilizarea supraîncărcării operatorului în combinație cu variabile polimorfe face inevitabil să se determine în mod dinamic ce cod să apeleze.

Critică

Utilizarea supraîncărcării nu este considerată un avantaj de către toți experții. Dacă supraîncărcarea funcțiilor și procedurilor nu este, în general, inacceptabilă (parțial pentru că nu duce la unele probleme tipice de „operator”, parțial pentru că este mai puțin tentant să o folosiți greșit), atunci supraîncărcarea operatorului este, în principiu, și în anumite implementări ale limbajului, este supus unor critici destul de severe din partea multor teoreticieni și practicieni ai programării.

Criticii subliniază că problemele de identificare, precedență și asociativitate evidențiate mai sus fac adesea ca tratarea cu operatori supraîncărcați fie inutil de dificilă, fie nefirească:

• Identificare. Dacă limbajul are reguli stricte de identificare, atunci programatorul este forțat să-și amintească pentru ce combinații de tipuri există operații supraîncărcate și să le transmită manual operanzi. Dacă limbajul permite identificarea „aproximativă”, nu se poate fi niciodată sigur că într-o situație destul de complicată se va executa exact varianta operației pe care programatorul o avea în vedere.
• Prioritate și asociativitate. Dacă sunt definite rigid, acest lucru poate fi incomod și nu este relevant pentru domeniul subiectului (de exemplu, pentru operațiuni cu seturi, prioritățile diferă de cele aritmetice). Dacă pot fi setate de programator, aceasta devine o sursă suplimentară de erori (fie și numai pentru că diferite variante ale unei singure operații se dovedesc a avea priorități diferite, sau chiar asociativitate).

Cât de mult poate depăși comoditatea utilizării propriilor operațiuni pe inconvenientul deteriorării controlabilității programului este o întrebare care nu are un răspuns clar.

Din punctul de vedere al implementării limbii, aceleași probleme duc la complexitatea traducătorilor și la scăderea eficienței și fiabilității acestora. Și utilizarea supraîncărcării împreună cu variabilele polimorfe este, de asemenea, evident mai lentă decât apelarea unei operații hardcoded în timpul compilării și oferă mai puține oportunități de optimizare a codului obiect. Caracteristicile specifice ale implementării supraîncărcării în diferite limbi sunt supuse unor critici separate. Deci, în C++, obiectul criticii poate fi lipsa unui acord privind reprezentarea internă a denumirilor de funcții supraîncărcate, ceea ce dă naștere la incompatibilități la nivelul bibliotecilor compilate de diferiți compilatori C++.

Unii critici vorbesc împotriva operațiunilor de supraîncărcare, pe baza principii generale teoria dezvoltării softwareși practică industrială reală.

• Susținătorii abordării „puritane” a construirii limbajului, cum ar fi Wirth sau Hoare, se opun supraîncărcării operatorului pur și simplu pentru că se poate renunța cu ușurință. În opinia lor, astfel de instrumente nu fac decât să complice limba și traducătorul, fără a furniza corespunzătoare acestei complicații caracteristici suplimentare. În opinia lor, însăși ideea de a crea o extensie a limbii orientată spre sarcini pare doar atractivă. În realitate, utilizarea instrumentelor de extensie a limbajului face ca programul să fie înțeles doar pentru autorul său - cel care a dezvoltat această extensie. Programul devine mult mai dificil de înțeles și analizat pentru alți programatori, ceea ce face mai dificilă întreținerea, modificarea și dezvoltarea echipei.
• Se observă că însăși posibilitatea utilizării supraîncărcării joacă adesea un rol provocator: programatorii încep să o folosească oriunde este posibil, ca urmare, un instrument conceput pentru a simplifica și eficientiza programul devine cauza complicației și confuziei sale.
• Este posibil ca operatorii supraîncărcați să nu facă exact ceea ce se așteaptă de la ei, în funcție de felul lor. De exemplu, a + b de obicei (dar nu întotdeauna) înseamnă același lucru ca b + a , dar „unu” + „două” este diferit de „două” + „unu” în limbile în care operatorul + este supraîncărcat pentru concatenare de șiruri.
• Supraîncărcarea operatorului face fragmentele de program mai sensibile la context. Fără a cunoaște tipurile de operanzi implicați într-o expresie, este imposibil de înțeles ce face expresia dacă folosește operatori supraîncărcați. De exemplu, într-un program C++, instrucțiunea<< может означать и побитовый сдвиг, и вывод в поток. Выражение a << 1 возвращает результат побитового сдвига значения a на один бит влево, если a - целая переменная, но если a является выходным потоком , то же выражение выведет в этот поток строку «1» .

Clasificare

Următoarea este o clasificare a unor limbaje de programare în funcție de faptul dacă permit supraîncărcarea operatorului și dacă operatorii sunt limitați la un set predefinit:

Supraîncărcarea funcțiilor este definiția mai multor funcții (două sau mai multe) cu același nume, dar cu parametri diferiți. Seturile de parametri ai funcțiilor supraîncărcate pot diferi în ordine, număr și tip. Astfel, este necesară supraîncărcarea funcțiilor pentru a evita duplicarea denumirilor funcțiilor care efectuează acțiuni similare, dar cu o logică de program diferită. De exemplu, luați în considerare funcția areaRectangle(), care calculează aria unui dreptunghi.

Float areaRectangle(float, float) //funcție care calculează aria unui dreptunghi cu doi parametri a(cm) și b(cm) ( returnează a * b; // înmulțim lungimile laturilor dreptunghiului și returnăm produsul rezultat)

Deci, aceasta este o funcție cu doi parametri de tip float, iar argumentele transmise funcției trebuie să fie în centimetri, valoarea returnată a tipului float este tot în centimetri.

Să presupunem că datele noastre inițiale (laturile dreptunghiulare) sunt date în metri și centimetri, de exemplu: a = 2m 35 cm; b = 1m 86 cm.În acest caz, ar fi convenabil să folosiți o funcție cu patru parametri. Adică, fiecare lungime a laturilor dreptunghiului este transmisă funcției în doi parametri: metri și centimetri.

Float areaRectangle(float a_m, float a_sm, float b_m, float b_sm) // funcție care calculează aria unui dreptunghi cu 4 parametri a(m) a(cm); b(m) b(cm) ( return (a_m * 100 + a_sm) * (b_m * 100 + b_sm); )

În corpul funcției, valorile care au fost transmise în metri (a_m și b_m) sunt convertite în centimetri și adăugate la valorile a_sm b_sm , după care înmulțim sumele și obținem aria dreptunghiului în cm. Desigur, a fost posibil să convertiți datele originale în centimetri și să folosiți prima funcție, dar acum nu este vorba despre asta.

Acum, cel mai important este că avem două funcții, cu semnături diferite, dar aceleași nume (funcții supraîncărcate). O semnătură este o combinație a unui nume de funcție cu parametrii săi. Cum se apelează aceste funcții? Și apelarea funcțiilor supraîncărcate nu este diferită de apelarea funcțiilor obișnuite, de exemplu:

ZonaRectunghi(32, 43); // se va apela o funcție care calculează aria unui dreptunghi cu doi parametri a(cm) și b(cm) areaRectangle(4, 43, 2, 12); // se va apela o funcție care calculează aria unui dreptunghi cu 4 parametri a(m) a(cm); b(m) b(cm)

După cum puteți vedea, compilatorul va selecta independent funcția dorită, analizând doar semnăturile funcțiilor supraîncărcate. Ocolind supraîncărcarea funcției, s-ar putea declara pur și simplu o funcție cu un alt nume și și-ar face bine treaba. Dar imaginați-vă ce se va întâmpla dacă aveți nevoie de mai mult de două astfel de funcții, de exemplu 10. Și pentru fiecare trebuie să veniți cu un nume semnificativ, iar cel mai greu lucru de reținut sunt acestea. Tocmai de aceea este mai ușor și mai bine să supraîncărcați funcțiile, cu excepția cazului în care, desigur, este nevoie de acest lucru. Codul sursă al programului este prezentat mai jos.

#include „stdafx.h” #include << "S1 = " << areaRectangle(32,43) << endl; // вызов перегруженной функции 1 cout << "S2 = " << areaRectangle(4, 43, 2, 12) << endl; // вызов перегруженной функции 2 return 0; } // перегруженная функция 1 float areaRectangle(float a, float b) //функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см) { return a * b; // умножаем длинны сторон прямоугольника и возвращаем полученное произведение } // перегруженная функция 2 float areaRectangle(float a_m, float a_sm, float b_m, float b_sm) // функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм) { return (a_m * 100 + a_sm) * (b_m * 100 + b_sm); }

// cod Cod::Blocuri

// Cod Dev-C++

#include folosind namespace std; // prototipuri de funcții supraîncărcate float areaRectangle(float a, float b); float areaRectangle(float a_m, float a_sm, float b_m, float b_sm); int main() ( cout<< "S1 = " << areaRectangle(32,43) << endl; // вызов перегруженной функции 1 cout << "S2 = " << areaRectangle(4, 43, 2, 12) << endl; // вызов перегруженной функции 2 return 0; } // перегруженная функция 1 float areaRectangle(float a, float b) //функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см) { return a * b; // умножаем длинны сторон прямоугольника и возвращаем полученное произведение } // перегруженная функция 2 float areaRectangle(float a_m, float a_sm, float b_m, float b_sm) // функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм) { return (a_m * 100 + a_sm) * (b_m * 100 + b_sm); }

Rezultatul programului este prezentat în Figura 1.

Cum se obține supraîncărcarea funcției în C? (10)

Există o modalitate de a obține supraîncărcarea funcției în C? Mă uit la funcții simple care pot fi supraîncărcate cum ar fi

foo (int a) foo (char b) foo (float c , int d)

Cred că nu există o cale directă; Caut soluții, dacă există.

Sper că codul de mai jos vă va ajuta să înțelegeți supraîncărcarea funcției