Punkt

#include <iostream>

class Punkt {

  public:
    int x;
    int y;

  Punkt() {
    // DEFAULT constructor
  }

  Punkt(int x, int y) {
    this->x = x;
    this->y = y;
  }

  /*
  ========================================================================================

  1. Zeby zmodyfikowac jakis obiekt w srodku metody i zeby bylo to widoczne po wyjsciu z tej
  metody to musi on byc wskaznikiem (adresem)

  W przeciazaniu operatorow w takiej sytuacji, gdy zmieniamy wartosc 'thisa' to
  zwracany typ zatem musi wskaznikiem, dlatego oznaczamy go albo '*' albo '&'

  2. Pierwszy argument moze byc pominiety, jest domniemany jezeli chodzi o aktualny obiekt np.

  p = p + 5

  To operator = nie potrzebuje takiej definicji
  operator+(Punkt p, int x)
  Pierwszy argument mozna pominac i zrobic to tak:
  operator+(int x)

  Inaczej jest jak mamy taki zapis:
  p = 5 + p
  Wtedy potrzebujemy to zrobic tak:
  operator+(int x, Punkt p)

  (!!!) WAZNE - takiego operatora nie zdefiniujemy w klasie Punkt, musi byc on gdzies poza ta klasa
  Napisalem Ci taki w mainie
  ========================================================================================
  */


  // .................................... OPERATOR += .................................... //
  Punkt& operator +=(Punkt &v) {
    this->x += v.x;
    this->y += v.y;
    return * this;
    // 'this' jest adresem, jak chcemy zwrocic jego zawartosc (obiekt, nie adres),
    // to trzeba go wyciagnac uzywajac '*'
    // Gdybysmy zwracali Punkt* to wystarczy 'return this'
  }


  // .................................... OPERATOR = ..................................... //
  // Generalnie to jest chyba jeden hoy czy dasz w argumencie &p czy p, i tak nie zmieniamy
  // wartosci tego argumentu wiec adres (referencja, wskaznik) wogole nie jest potrzebny
  // ale z jakiegos zjebanego powodu w wiekszosci tutorialow jest ta referencja &
  //
  // Tutaj akurat jest problem, bo bez & tak wyglada defaultowy operator =
  // W momencie jak go nadpisze operator=(Punkt &p) to wymagane jest referencji, czyli
  //
  // Punkt p = Punkt(5,10);
  // p = Punkt(10,20) <----- nie mozna tak zrobic, bo Punkt(10,20) nie jest referencja! nie skompiluje sie
  // wiec w tym operatorze zostawilem to bez '&' bo w mainie resetuje te wartosci
  // Bezpieczniej jest dawac te & bo te ciule sie przypierdola pewnie o to
  Punkt& operator =(Punkt p) {
    this->x = p.x;
    this->y = p.y;
    return * this;
  }


  // .................................... OPERATOR == .................................... //
  bool operator ==(Punkt &p) {
    return (this->x == p.x) && (this->y == p.y);
  }


  // .................................... OPERATOR + .................................... //
  Punkt operator +(Punkt &v) {
    int nowyX = this->x + v.x;
    int nowyY = this->y + v.y;
    Punkt nowyPunkt = Punkt(nowyX, nowyY);

    return nowyPunkt;
  }



};