Difference between revisions of "Supraîncărcarea operatorilor în limbajul C-plus-plus"

using namespace std;

class MyPoint

{
public:
   MyPoint(); // constructor implicit
   MyPoint( const double a ); // constructor de initializare
   MyPoint( const double a, const double b ); // constructor de initializare
   MyPoint( const MyPoint &r ); // constructor de copiere

   MyPoint& operator+=( const MyPoint& point ); // adunare cu un alt punct
   MyPoint& operator-=( const MyPoint& point ); // scadere
   MyPoint& operator*=( const double dVal ); // inmultire cu o constanta

   // considerand punctul ca un vector de 2 elemente ( pozitiile 0,1 ), pe pozitia 0 fiind x
   // NOTA: nu este recomandat, este doar un exemplu de utilizare al operatorului []
   double & operator[]( const int index );

   friend MyPoint operator+ (const MyPoint& p1, const MyPoint& p2); // suma a 2 vectori
   friend MyPoint operator- (const MyPoint& p1, const MyPoint& p2); // diferenta a 2 vectori
   double operator*( const MyPoint& point ) const; // produsul scalar a 2 vectori
   MyPoint operator*( const double dVal ) const; // multiplicare cu o constanta
   friend MyPoint operator*( const double dVal, const MyPoint& point); // pentru a asigura comutativitatea operatiei precedente

   MyPoint& operator=( const MyPoint& point );

   MyPoint& operator++(); // ++ prefixat
   MyPoint operator++( int ); // ++ postfixat

   friend ostream& operator<<( ostream &stream, const MyPoint &pt );
   friend istream& operator>>( istream &stream, MyPoint &pt );

   void   setX( double x );
   double getX() const;

   void   setY( double y );
   double getY() const;
private:
   double x;
   double y;
};

MyPoint::MyPoint()
{
   x = 0;
   y = 0;
}

MyPoint::MyPoint( const MyPoint &r )
{
   x = r.x;
   y = r.y;
}

MyPoint::MyPoint( const double a )
{
   x = a;
   y = a;
}

MyPoint::MyPoint( const double a, const double b )
{
   x = a;
   y = b;
}

MyPoint& MyPoint::operator+=( const MyPoint& point )
{
   x+=point.x;
   y+=point.y;
   return *this;
}

MyPoint& MyPoint::operator-=( const MyPoint& point )
{
   x-=point.x;
   y-=point.y;
   return *this;
}

MyPoint& MyPoint::operator*=( const double dVal )
{
   x*=dVal;
   y*=dVal;
   return *this;
}

MyPoint operator+ (const MyPoint& p1, const MyPoint& p2)
{
   MyPoint temp;
   
   temp.x = p1.x + p2.x;
   temp.y = p1.y + p2.y;
   
   return temp;
}

MyPoint operator- (const MyPoint& p1, const MyPoint& p2)
{
   MyPoint temp;
   
   temp.x = p1.x - p2.x;
   temp.y = p1.y - p2.y;
   
   return temp;
}

double MyPoint::operator*( const MyPoint& point ) const
{
   // produs vectorial intre 2 vectori
   // fiecare vector e determinat de origine si coordonatele punctului
   return x * point.x + y * point.y;
}

MyPoint MyPoint::operator*( const double dVal ) const
{
   return MyPoint(x * dVal, y * dVal);
}

MyPoint operator*( const double dVal, const MyPoint& point )
{
   return MyPoint(point.x * dVal, point.y * dVal);
}

MyPoint& MyPoint::operator=( const MyPoint& point )
{
   x = point.x;
   y = point.y;
   return *this;
}

MyPoint& MyPoint::operator++()
{
   x++;
   y++;
   return *this;
}

MyPoint MyPoint::operator++( int )
{
   MyPoint r = *this;
   x++;
   y++;
   return r;
}

ostream& operator<<( ostream &stream, const MyPoint &pt )
{
   stream << "( " << pt.x << ", " << pt.y << " )";
   return stream;
}

istream& operator>>( istream &stream, MyPoint &pt )
{
   stream >> pt.x >> pt.y;
   return stream;
}

void MyPoint::setX( double x )
{
   this->x = x;
}

double MyPoint::getX() const
{
   return x;
}

void MyPoint::setY( double y )
{
   this->y = y;
}

double MyPoint::getY() const
{
   return y;
}

double& MyPoint::operator[]( const int index ) { if( index == 0 ) return x; return y; }

int main( int argc, char *argv[] )
{
   // initializarea punctelor
   MyPoint pt( 5, 7 );
   MyPoint pt2;

   // test pentru serializare    
   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 )

   pt = MyPoint( 1, 3 );
   
   // Multiplicarea cu o constanta. folosirea operatorului *
   // Folosim atat operatorul * cat si operatorul * ca si metoda friend.
   // 2 * pt este echivalent cu: *(2, pt)
   // pt * 2 este echivalent cu: pt.*(2)
   cout << 2 * pt << " " << pt * 2 << endl; // afiseaza la consola ( 2, 6 ) (2, 6)

   // folosirea operatorului [] supraincarcat.
   cout << "x pt[0]=" << pt[0] << "; y pt[1]=" << pt[1] << endl;
   pt[0] = 5;
   pt[1] = 5;
   
   pt2 = pt;
   
   // Folosirea operatorului + si - supraincarcate si a constructorului
   // cu un singur parametru double. Avantajul e ca logica + e definita
   // intr-un singur loc. Dezavantajul e chemarea transparenta a constructorului
   // si creerea unui obiect temporar.
   pt2 = pt2 - 2; // echivalent cu: pt2.=(pt2.-(MyPoint(2)));
   cout << pt2 << endl;
   
   pt2 = 2 + pt2; // echivalent cu: pt2.=(MyPoint(2).+(pt2));
   cout << pt2 << endl;

   pt2 = pt2 + pt2; // echivalent cu: pt2.=(pt2.+(pt2));
   cout << pt2 << endl;

   return 0;
}