Supraîncărcarea, programare pe c și c

operatori de suprasarcină C ++ (suporturi). supraîncărcarea operatorului Cu puține excepții, majoritatea operatorilor C ++ poate fi suprasolicitat ca urmare a care vor primi o valoare ING specială în ceea ce privește anumite clase. De exemplu, o clasă care definește o listă legate de egalitate, se poate utiliza operatorul + pentru a adăuga un obiect la listă. O altă clasă poate utiliza operatorul + un mod complet diferit. Atunci când un operator este supraîncărcat, nici una din valoarea sa inițială nu pierde sensul. Doar un nou operator este definit pentru o anumită clasă de obiecte. Prin urmare, supraîncărcarea operatorului + să se ocupe de-con legat listă nu se schimbă acțiunile sale în raport cu numere întregi.

Funcțiuni de antrenare, de obicei, sunt fie membri sau prieteni ai clasei pentru care sunt utilizate. In ciuda multe similitudini, există o diferență certă între od-Bami, care supraîncărcat funcții membre ale operatorului și operatorului funcții-prieteni. În această secțiune considerăm doar funcțiile de membru de suprasarcină. Mai târziu în acest capitol până în prezent, Zano, cum supraîncărcată funcțiile de operator, prieteni.

Pentru a supraîncărca un operator, aveți nevoie pentru a determina ce se înțelege de către operator în ceea ce privește clasa la care este aplicat. În acest scop, aceasta definește o funcție pentru operatorul care specifică acțiunea operatorului. Forma generală a funcției operatorului de cazul în care acesta este un membru al clasei este după cum urmează:

nume de tip :: operator de # (Listă de argumente)
// acțiuni definite în raport cu clasa
>

Aici operatorul supraîncărcat este înlocuit cu simbolul #, iar tipul specifică tipul de valori, OMS-rotite de către operator. Pentru a simplifica utilizarea unui operator supraîncărcat
expresii complexe, ca valoare de retur pentru a alege de multe ori de același tip ca clasa pentru care este supraîncărcat operatorul. Natura lista de argumente nu este determinată de mai mulți factori, după cum se va vedea mai jos.

Pentru a vedea modul în care Reacoperirea, începe cu un exemplu simplu. Se va construi clasa etsya three_d, care cuprinde coordonatele obiectului în spațiu tridimensional. Următorul pro-gram suprasarcini + = și la three_d clasă:

#include
class three_d int x, y, z; // coordonatele tridimensionale
publice:
Operatorii three_d + (three_d t);
Operatorul three_d = (three_d t);
void spectacol ();
void Assign (int mx, int meu, int mz);
>;
// suprasarcina +
three_d three_d :: operatorului + (three_d t)
temp three_d;
temp.x = x + T.x;
temp.u = y + t.y;
temp.z = z + t.z;
temperaturii pe retur;
>
// suprasarcină =
three_d three_d :: Operatorul = (three_d t)
x = T.x;
y = t.y;
z = t.z;
întoarce * acest lucru;
>
// ieșire coordonatele X, Y, Z
void three_d :: spectacol ()
cout < cout <<у <<", ";
cout <>
// Coordonate Alocarea
void three_d :: Assign (int mx, int meu, int mz)
x = mx;
y = meu;
mz = z;
>
int main ()
three_d a, b, c;
a.assign (1, 2, 3);
b.assign (10, 10, 10);
a.show ();
b.show ();
c = a + b; // Adăugarea a și b
c.show ();
c = a + b + c; // adăugarea a, b și
s.show ();
a = b = a; // demonstratie de atribuire multiple
s.show ();
b.show ();
return 0;
>

Acest program afișează următoarele informații:

1, 2, 3
10, 10, 10
11, 12, 13
22, 24, 26
1, 2, 3
1, 2, 3

Dacă luăm în considerare programul cu atenție ca o surpriză faptul că ambele funcții, operatorul-Rathor are un singur parametru, în ciuda faptului că acestea suprasarcină un operator binar. Acest lucru se datorează faptului că, în caz de suprasarcină unui operator binar utilizând funcția ei membru a transmis în mod explicit doar un singur argument. Al doilea argument este ASC-riența acest lucru, care este trecut la ea în mod implicit. Astfel, în linie

x corespunde this-> x, unde x este asociat cu un obiect, care apelează operatorul funcției. În toate cazurile, este un obiect la stânga semnului operațiunii solicită operatorului. Obiect în picioare la dreapta operațiunii semn, a trecut la o funcție.

Când supraîncărcarea funcția de operare unară, operatorul nu are parametri, iar operatorul funcția este un parametru în operația binară este supraîncărcat. (Nu supraîncărcați operatorul triada.) În toate cazurile, funcția de obiect este activat, operatorul este transmis implicit la timp folosind acest indicator.

O altă cheie Reacoperirea plus este că returnează un obiect de tip three_d. Deși funcția poate avea ca valoare orice tip validă Yazi unică C ++, faptul că acesta returnează tipul de obiect three_d, permite operatorului + pentru expresii mai complexe, cum ar fi a + b + c. În cazul în care a + b produce un rezultat de tip three_d. Această valoare este apoi adăugată la c. În cazul în care valoarea suma a + b a avut o valoare de alt tip, nu am putut apoi adăugați-l la o.

Spre deosebire de operatorul +, operatorul de atribuire modifică argumentele sale. (Acest lucru, printre altele, este sensul de atribuire.) Deoarece operatorul = function () este numit de obiect în stânga semnului egal, atunci acel obiect este modificat
atunci când efectuează operațiuni de atribuire. Cu toate acestea, chiar și operatorul de atribuire este obligat importanță RETURN Schat ca în C ++, iar operatorul de atribuire produce cantitatea de pe partea dreaptă a egalității. Deci, la următoarea expresie

A fost valabilă, este necesar ca operatorul operatorul = () returnează obiectul la care UCA leagă acest pointerul și obiectul va fi în picioare pe partea stângă a operatorului prin atribuirea-TION. Dacă faceți acest lucru, puteți efectua atribuirea multiplă.

Puteți supraîncărca operatorii unare, cum ar fi ++ sau -. Așa cum am menționat mai devreme, atunci când supraîncărcarea operatorului unar utilizând o funcție de membru, această funcție membru nu are argumente. În schimb, operația este realizată pe obiectul realizării funcțiilor operator call prin transferul implicit al acestui indicator. Ca un exemplu, sub-considerată versiune extensie rennaya a programului precedent, care definește-increment operator three_d tip de obiect:

#include
class three_d int x, y, z; // coordonatele tridimensionale
publice:
Operatorul three_d + (three_d OP2); // OP1 a însemnat
Operatorul three_d = (three_d OP2); // OP1 a însemnat
Operatorul three_d ++ (); // OP1 este destinat, de asemenea
void spectacol ();
void Assign (int mx, int meu, int mz);
>;
// suprasarcina +
three_d three_d :: operatorul + (three_d OP2)
temp three_d;
temp.x = x + op2.x; // asignarea întreg
temp.u = y + op2.y; // în acest caz, păstrează +
temp.z = z + op2.z; // valoarea inițială
temperaturii pe retur;
>
// suprasarcină =
three_d three_d :: Operatorul = (three_d OP2)
x = op2.x; // alocare întreg
y = op2.y; // în acest caz reține =
z = op2.z; // valoarea inițială
întoarce * acest lucru;
>
// unar suprasarcină
three_d three_d :: operatorul ++ ()
x ++;
y ++;
z ++;
întoarce * acest lucru;
>
// afișa coordonatele X, Y, Z
void three_d :: spectacol ()
cout < cout <<у <<", ";
cout <>
// Coordonate Alocarea
void three_d :: Assign (int mx, int meu, int mz)
x = mx;
y = meu;
mz = z;
>
int main ()
three_d a, b, c;
a.assign (1, 2, 3);
b.assign (10, 10, 10);
a.show ();
b.show ();
c = a + b; // Adăugarea a și b
c.show ();
c = a + b + c; // adăugarea a, b și
s.show ();
a = b = a; // demonstratie de atribuire multiple
s.show ();
b.show ();
++c; // creștere de la
c.show ();
return 0;
>

In versiunile anterioare de C ++, era imposibil să se determine, înainte sau după operatorul operanzi supraîncărcat ++ sau -. De exemplu, pentru un obiect cu privire la următoarele două afirmații sunt identice:

Cu toate acestea, mai târziu versiuni de C ++ permite să se facă distincția între operatori prefix și postfix tors-increment și decrementare. Pentru a face acest lucru, programul ar trebui să identifice cele două versiuni ale operatorului ++ funcția (). Unul dintre ele ar trebui să fie la fel ca în programul anterior. Drew Gaya a declarat după cum urmează:

operator de loc ++ (int x);

Dacă ++ precede operandul, funcția se numește operatorul ++ (). Dacă ++ urmează operandul, atunci funcția se numește operatorul ++ (int x), unde x ia valoarea 0.

Acțiunea operatorului supraîncărcat în ceea ce privește clasa pentru care este definit, in nu trebuie să se conformeze în nici un fel acțiunea acestui operator pentru built-in tipuri de C ++. De exemplu, operatorii <<и>> Trimitere la cin și cout au puține în comun cu efectul lor asupra variabilelor întregi. Cu toate acestea, în funcție de dorința de a face codul mai ușor de citit și bine structurat, este de dorit ca supraîncărcat Opera-torii corespund, după caz, în sensul operatorilor originale. De exemplu, operatorul + pentru clasa three_d conceptual similar cu operatorul + pentru variabile de tip întreg. utilizarea Little, de exemplu, poate fi de așteptat de la un astfel de operator de +, a cărui acțiune pe
clasa corespunzătoare va semăna cu acțiunea operatorului ||. Deși este posibil să se dea operatorului supraîncărcat-zhennomu orice sentiment de propria lor alegere, ci pentru claritatea cererii sale este de dorit ca noua valoare a fost legată de valoarea inițială.

Există unele limitări privind Reacoperirea. În primul rând, nu se poate schimba în cazul în care operatorul-priorităŃii. În al doilea rând, nu puteți schimba numărul de operanzi ai operatorului. În cele din urmă, pentru operatorii excluși-cheniem operatorul de atribuire supraîncărcat moștenite de către orice clasă derivată. Fiecare clasă trebuie să definească în mod clar propriile operatori supraîncărcate, Rathore = în cazul în care este necesar pentru orice scop. Desigur, clasele derivate pot re-încărca orice operator, inclusiv una care a fost supraîncărcat clasa de baza. Următorii operatori nu pot fi supraîncărcat:
. *?