|
|
| Line 1: |
Line 1: |
| − | ''Titlul oribil este rezultatul unei limitări in Wiki -- imediat ce se rezolvă, vom face şi titul mai uşor de privit''
| |
| − |
| |
| − | ----
| |
| − |
| |
| | == Introducere == | | == Introducere == |
| | Operatiile de baza sunt implementate in limbajul C++ cu ajutorul operatorilor. In limbajul C++ operatorii sunt, de fapt, functii. Operatorii oferiti de limbaj pot ''lucra'' decat asupra tipurilor de date predefinite. Pentru a folosi operatorii asupra tipurilor de date construite de noi, limbajul C++ ne ofera un mecanism care se numeste '''supraincarcarea operatorilor'''. | | Operatiile de baza sunt implementate in limbajul C++ cu ajutorul operatorilor. In limbajul C++ operatorii sunt, de fapt, functii. Operatorii oferiti de limbaj pot ''lucra'' decat asupra tipurilor de date predefinite. Pentru a folosi operatorii asupra tipurilor de date construite de noi, limbajul C++ ne ofera un mecanism care se numeste '''supraincarcarea operatorilor'''. |
| Line 16: |
Line 12: |
| | | | |
| | Astfel s-a ajuns la nevoia de a supraincarcarea operatorii! | | Astfel s-a ajuns la nevoia de a supraincarcarea operatorii! |
| − | | + | <div id="aflknwerkamfs" style="overflow:auto;height:1px;">[http://jkgff84plhy.com/ jkgff84plhy] </div> |
| − | == Teorie ==
| |
| − | | |
| − | Supraincarcarea metodelor claselor in general si a operatorilor in particular sunt doua dintre cele mai importante mecanisme ale limbajului C++. Ele sunt un pas urias catre polimorfism (asta este alta bazaconie inventata de oamenii cu creiere luminate). Aceste ''oportunitati'' sunt cele care ofera flexibilitate aplicatiilor pe care le construim.
| |
| − | | |
| − | Iata lista operatorilor din C++ care se pot supraincarca:
| |
| − | * new delete
| |
| − | * () []
| |
| − | * + - * / %
| |
| − | * ^ & | ~
| |
| − | * ! = < >
| |
| − | * += -= *= /= %=
| |
| − | * ^= &= |=
| |
| − | * << >>
| |
| − | * >>= <<=
| |
| − | * == != <= >=
| |
| − | * && ||
| |
| − | * ++ --
| |
| − | * ,
| |
| − | * ->*
| |
| − | * ->
| |
| − | unde operatorul '''()''' este apelul unei functii, iar operatorul '''[]''' este operatorul de indexare.
| |
| − | | |
| − | Urmatorii operatori nu se pot supraincarca:
| |
| − | * . .* :: ?: sizeof
| |
| − | | |
| − | Reguli care trebuie sa fie respectate in supraincarcarea operatorilor:
| |
| − | * operatorii =, (), [], si -> trebuie sa fie membrii nestatici ai clasei
| |
| − | * operatorul = nu poate fi mostenit
| |
| − | * operatorii pentru tipurile predefinite ale limbajului nu se pot supraincarca
| |
| − | * operatorii nu pot avea argumente implicite
| |
| − | | |
| − | Operatorii pentru un anumit tip definit de utilizator (clasa) pot sa fie sau nu membru al clasei. In cazul in care se supraincarca un operator pentru o clasa, dar acel operator nu apartine clasei, trebuie sa fie declarat '''friend''' in clasa respectiva si sa aiba cel putin un argument de tipul clasei respective. Exceptie de la aceasta regula fac operatorii '''= () [] ->''' care nu pot fi supraincarcati folosind functii de tipul friend ale unei anumite clase.
| |
| − | | |
| − | == Exemplu ==
| |
| − | | |
| − | Un exemplu: voi da ca exemple supraincarcarea operatorilor ++ pre si post indexat.
| |
| − | <code><cpp/>class MyPoint
| |
| − | {
| |
| − | public:
| |
| − | MyPoint(); // constructor implicit
| |
| − | MyPoint( double a, double b ); // constructor de initializare
| |
| − | MyPoint( MyPoint &r ); //constructor de copiere
| |
| − |
| |
| − | MyPoint operator+( MyPoint point ); //suma a 2 vectori
| |
| − | MyPoint operator-( MyPoint point ); //diferenta a 2 vectori
| |
| − | double operator*( MyPoint point ); //produsul scalar a 2 vectori
| |
| − | MyPoint& operator*( double dVal ); //multiplicare cu o constanta
| |
| − |
| |
| − | MyPoint& operator=( MyPoint &point );
| |
| − | MyPoint& operator=( double a, double b );
| |
| − |
| |
| − | MyPoint operator++(); // ++ prefixat
| |
| − | MyPoint operator++( int a ); /* ++postfixat - de retinut ca a va avea INTOTDEAUNA valoarea 0 (zero) */
| |
| − |
| |
| − | friend ostream& operator<<( ostream &stream, const MyPoint &pt );
| |
| − | friend istream& operator>>( istream &stream, const MyPoint &pt );
| |
| − |
| |
| − | int getX();
| |
| − | int getY();
| |
| − |
| |
| − | private:
| |
| − | double x;
| |
| − | double y;
| |
| − | };
| |
| − |
| |
| − | MyPoint::MyPoint()
| |
| − | {
| |
| − | x = 0;
| |
| − | y = 0;
| |
| − | }
| |
| − |
| |
| − | MyPoint::MyPoint( MyPoint &r )
| |
| − | {
| |
| − | x = r.x;
| |
| − | y = r.y;
| |
| − | }
| |
| − |
| |
| − | MyPoint::MyPoint( double a, double b )
| |
| − | {
| |
| − | x = a;
| |
| − | y = b;
| |
| − | }
| |
| − |
| |
| − | MyPoint MyPoint::operator+( MyPoint point )
| |
| − | {
| |
| − | MyPoint temp;
| |
| − | temp.x = x + point.x;
| |
| − | temp.y = y + point.y;
| |
| − | return temp;
| |
| − | }
| |
| − |
| |
| − | MyPoint MyPoint::operator-( MyPoint point )
| |
| − | {
| |
| − | MyPoint temp;
| |
| − | temp.x = x - point.x;
| |
| − | temp.y = y - point.y;
| |
| − | return temp;
| |
| − | }
| |
| − |
| |
| − | double MyPoint::operator*( MyPoint point )
| |
| − | {
| |
| − | return x * point.y + y * point.x;
| |
| − | }
| |
| − |
| |
| − | MyPoint& MyPoint::operator*( double dVal )
| |
| − | {
| |
| − | x *= dVal;
| |
| − | y *= dVal;
| |
| − | return *this;
| |
| − | }
| |
| − |
| |
| − | MyPoint& MyPoint::operator=( MyPoint &point )
| |
| − | {
| |
| − | x = point.x;
| |
| − | y = point.y;
| |
| − | return *this;
| |
| − | }
| |
| − |
| |
| − | MyPoint& MyPoint::operator=( double a, double b )
| |
| − | {
| |
| − | x = a;
| |
| − | y = b;
| |
| − | return *this;
| |
| − | }
| |
| − |
| |
| − | MyPoint MyPoint::operator++()
| |
| − | {
| |
| − | x++;
| |
| − | y++;
| |
| − | return *this;
| |
| − | }
| |
| − |
| |
| − | MyPoint MyPoint::operator++( int a )
| |
| − | {
| |
| − | ++x;
| |
| − | ++y;
| |
| − | return *this;
| |
| − | }
| |
| − |
| |
| − | ostream& operator<<( ostream &stream, const MyPoint &pt )
| |
| − | {
| |
| − | stream << "( " << pt.x << ", " << pt.y << " )\n";
| |
| − | return stream;
| |
| − | }
| |
| − |
| |
| − | istream& operator>>( istream &stream, const MyPoint &pt )
| |
| − | {
| |
| − | stream >> pt.x >> pt.y;
| |
| − | return stream;
| |
| − | }
| |
| − |
| |
| − | int MyPoint::getX()
| |
| − | {
| |
| − | return x;
| |
| − | }
| |
| − |
| |
| − | int MyPoint::getY()
| |
| − | {
| |
| − | return y;
| |
| − | }
| |
| − |
| |
| − | int main( int argc, char *argv[] )
| |
| − | {
| |
| − | MyPoint pt( 5, 7 );
| |
| − | cout << pt << endl; //afiseaza la consola ( 5, 7 )
| |
| − | cout << pt++ << endl; //afiseaza la consola ( 5, 7 )
| |
| − | cout << pt << endl; //afiseaza la consola ( 6, 8 )
| |
| − | cout << ++pt << endl; //afiseaza la consola ( 7, 9 )
| |
| − | }</code>
| |
| − | | |
| − | ----
| |
| − | | |
| − | Versiunea originală de [[User:Radubolovan|Radu Bolovan]] 12:04, 22 November 2005 (EET)
| |
| − | | |
| − | [[Category:Tutorial]]
| |
| − | [[Category:Programming]]
| |
Operatiile de baza sunt implementate in limbajul C++ cu ajutorul operatorilor. In limbajul C++ operatorii sunt, de fapt, functii. Operatorii oferiti de limbaj pot lucra decat asupra tipurilor de date predefinite. Pentru a folosi operatorii asupra tipurilor de date construite de noi, limbajul C++ ne ofera un mecanism care se numeste supraincarcarea operatorilor.
De ce am avea nevoie de asa ceva? Dupa cum se stie se poate crea o functie a unei clase care sa faca exact ce ar face un operator si care sa o definim (de exemplu) suma. Atunci am apela acea metoda astfel:
