No Dynamic Alloc

#include <iostream>
using namespace std;

class Kwadrat
{
    private:
        int height;
        int width;
    public:
        Kwadrat(int height = 0, int width = 0);
        /* Tutaj nie ma dynamicznej alokacji (new w konstruktorze)
         * ani tablicy, więc nie potrzebny jest customowy
         * konstruktor kopiujący, destruktor ani operator przypisania.
         * Wystarczą te automatycznie generowane przez kompilator,
         * co zostało poniżej zaznaczone przez '= default'. Można tego wgl nie pisać,
         * ale tak się oszczędza czas przy kompilacji, bo od razu mówi się
         * kompilatorowi żeby sam stworzył te metody - on nie traci czasu
         * na samodzielne dedukowanie tego.
         */
        Kwadrat(const Kwadrat& kwad) = default;             // konst. kopiujący
        ~Kwadrat() = default;                               // destruktor
        Kwadrat& operator=(const Kwadrat& kwad) = default;  // oper. przypisania
        Kwadrat operator+(const Kwadrat& kwad); // jakieś tam operacje
        /*friend operator+(const Kwadrat& kwad1, const Kwadrat& kwad2); // to dla porównania z powyższym*/
        Kwadrat operator-(const Kwadrat& kwad);
        Kwadrat operator*(const Kwadrat& kwad);
        void show();                            // zwykła metoda wyświetlająca, używająca cout

        /* Pod spodem znajduje się przeciążająca operator << funkcja zaprzyjaźniona z klasą.
         * Funkcje friend, nie są wywoływane na rzecz obiektu!
         * Dlatego ta funkcja bierze jako argument const Kwadrat& kwad i wyświetla jego pola.
         * Co to znaczy? Przykład:
         *
         * Kwadrat k1(2, 3);
         * cout << k1;
         *
         * W takim zapisie k1, nie wywołuje funkcji operator<<. Z tego powodu
         * wewnątrz funkcji this->height nie ma sensu i nie odwoływałoby się do niczego.
         */
        friend ostream& operator<<(ostream& os, const Kwadrat& kwad); // funkcja zaprzyjaźniona z klasą -> uwaga! to nie jest metoda klasy!

};

Kwadrat::Kwadrat(int height, int width) // konstruktor
{
    this->height = height;
    this->width = width;
}

/* Poniższe funkcje operator+ robią to samo.
 * Różnica jest tylko w sposobie zapisu.
 * Metody klasy są wywoływane na rzecz obiektu.
 * Wewnątrz metod klasy istnieje wskaźnik this, który odwołuje się do obiektu wywołującego metodę.
 * Oznacza to, że jeżeli mamy zapis w kodzie:
 *
 * k3 = k1 + k2;
 *
 * i zarówno k1, k2 i k3 to obiekty typu Kwadrat i zostaje wywołana metoda składowa operator+ to w zapisie
 *
 * temp.height = this->height + kwad.height;
 *
 * this->height jest równoważne k1.height
 * kwad.height jest równoważne k2.height
 *
 *
 * Funkcje zaprzyjaźnione nie są wywoływane na rzecz obiektu.
 * Oznacza to, że jeżeli potrzebują dwóch obiektów do wykonania operacji (na przykład dodawanie jest dwuargumentowe, nie?)
 * to oba obiekty muszą być przekazane jako argumenty.
 *
 * To powoduje różnice w wyglądzie inicjalizacji metody i funkcji zaprzyjaźnionej z klasą:
 *
 * Kwadrat operator+(const Kwadrat& kwad) ----> to jest metoda składowa i posiada obiekt wywołujący, więc jeden arg jest "ukryty"
 *                                              i dostępny w deklaracji pod wskaźnikiem this
 *
 * friend Kwadrat operator+(const Kwadrat& kwad1, const Kwadrat& kwad2) -----> to jest funkcja zaprzyjaźniona i one nie ma obiektu
 *                                                                             wywołującego, więc musi mieć dwa argumenty i co za tym idzie
 *                                                                             w deklaracji nie ma dostępu do wskaźnika this
 * Różnice w deklaracji polegają na tym, że w funkcji zaprzyjaźnionej NIE UŻYWAMY this.
 * Deklaracje zamieszczono poniżej.
 */

Kwadrat Kwadrat::operator+(const Kwadrat& kwad) // deklaracja metody składowej
{
    Kwadrat temp;
    temp.height = this->height + kwad.height; /* użyte this wskazujące na obiekt wywołujący */
    temp.width = this->width + kwad.width;
    return temp;
}

/*
Kwadrat operator+(const Kwadrat& kwad1, const Kwadrat& kwad2) // funkcja zaprzyjaźniona
{
    Kwadrat temp;
    temp.height = kwad1.height + kwad2.height; ---> brak dostępu do this, stąd przyjmuje 2 argumenty
    temp.width = kwad1.width + kwad2.width;
    return temp;
}
*/


Kwadrat Kwadrat::operator-(const Kwadrat& kwad)
{
    Kwadrat temp;
    temp.height = this->height - kwad.height;
    temp.width = this->width - kwad.width;
    return temp;
}


Kwadrat Kwadrat::operator*(const Kwadrat& kwad)
{
    Kwadrat temp;
    temp.height = this->height * kwad.height;
    temp.width = this->width * kwad.width;
    return temp;
}

void Kwadrat::show()
{
    cout << "Height: " << height << endl
         << "Width: " << width << endl;
}

/* Zaprzyjaźniona funkcja operatorowa << pozwalająca wyświetlić Kwadrat
 * przyjmuje referencje na obiekt typu ostream. Cout jest obiektem typu ostream.
 * Tutaj obiekt ostream ma nazwe os (obojętnie jaka) i do os streamujemy napis tak jak do cout.
 * Na koniec zwracamy os i śmiga tak:
 *
 * Kwadrat k1;
 * cout << k1;
 *
 * cout jest z lewej strony, ponieważ jest w funkcji jako pierwszy argument.
 * k1 jest z prawej strony, ponieważ jest w funkcji jako drugi argument.
 * Bierze const Kwadrat& jako argument, bo jak każda funkcja zaprzyjaźniona nie jest wywoływana przez obiekt.
 */
ostream& operator<<(ostream& os, const Kwadrat& kwad)
{
    os << "Height: " << kwad.height << endl
       << "Width: " << kwad.width << endl;
    return os;
}

int main()
{
    Kwadrat k(1, 2);
    k.show();
    cout << k;
    return 0;
}