#pragma once

#include <iostream>

#define SIZE  2

class Macierz {
public:
    Macierz();
    ~Macierz();
    void wypisz() const; // skąd ten straszny CONST?! WTF?! ten const obok nazwy metody oznacza że ta metoda nie będzie

modyfikować pól tej klasy (czyli u nas macierzy :)
    double getValue(const int posX, const int posY) const;
    void setValue(const int posX, const int posY, double value); // to zmienia jakąś cyferkę z macierzy o podanych

koordynatach- easy (nie ma consta za metodą, a wiesz czemu? ... podejdź to Ci powiem... bo ta metoda modyfikuje macierz, dobre co?

xD)
    friend std::ostream & operator<< (std::ostream &output, const Macierz& m); // jazda bez trzymanki xD funkcja

zaprzyjaźniona (NIE METODA!! xD) - dlaczego zaprzyjaźniona? bo to taka funkcyjka któa ma dostęp prywatnych danych klasy xD (zwróc

uwagę na definicję - nie ma tam "Macierz:: " <- jak wspomniałem to nie jest meotoda klasy macierz :) więcje niżej xD
    bool operator== (const Macierz& m) const; // to będzie do porównań czy jedna macierz równa się drugiej ;p
    Macierz & operator= (const Macierz &m); // to do przypisywania - zero filozofii
    Macierz operator* (const Macierz &m) const; // a to to do mnożenia
private:
    double **macierz; // wskaźniczek do wskaźniczków ;p czyli tablica 2d
};

//konstruktor alokuje pamiec dla dwuwymiarowej tablicy "macierz" oraz domyslnie wpisuje do niej same 0 by nie bylo tam krzakow xD
Macierz::Macierz() {
    macierz = new double * [SIZE]; najepierw tworzymy jednowymiarową tablicę wskaźników
    for (int i = 0; i < SIZE; ++i) {
        macierz[i] = new double[SIZE]; // teraz do każdej komórki wrzucamy tablicę już zwykłych wartości double - czyli

otrzymujemy tablicę 2d
        for (int j = 0; j < SIZE; ++j) { // tutaj dodatkowo ustawiamy wartości na 0
            macierz[i][j] = 0;
        }
    }
}

Macierz::~Macierz() { // tutaj musimy posprzątać po sobie, czyli zwalniamy pamięć po tablicy 2d - jak by była 1d to easy -

wstarczy delete [] tab xD; ale to jest 2d :)

    for (int i = 0; i < SIZE; ++i) { //skoro w każdej komórce jest jakaś tablica wskaźników to musimy ją całą prze.jechać xD i

opróżnić  każdą
        delete[] macierz[i];
    }
    delete[] macierz; // na końcu opróżniamy nadrzędną tablicę
    std::cout << "Pamiec zwolniona\n"; // wypisuje coś :) :)
}

// metoda wypisujaca macierz
// no wiadomo o co biega, co ja się będę tutaj produkował xDD
void Macierz::wypisz() const {
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            std::cout << macierz[i][j] << " ";
        }
        std::cout << "\n";
    }
}

double Macierz::getValue(const int posX, const int posY) const { // po co te consty przy tych intach? to informacja i jednocześnie

blokada, że nie będziemy w tej metodzie modyfikować posX oraz posY
    return this->macierz[posX][posY];
}

void Macierz::setValue(const int posX, const int posY, double value) {
    if (posX * posY <= 0 || posX > SIZE || posY > SIZE) {
        std::cout << "Nie można wstawić wartości.";
        return;
    }
    macierz[posX][posY] = value;
}

// sluzy wypisywaniu macierzy, dzieki temu możemy wypisywać macizerz w ten sposób : Macierz m; cout << m << endl;
std::ostream & operator<< (std::ostream &output, const Macierz &m) {
    return output << m.getValue(0, 0) << " " << m.getValue(0, 1) << "\n" << m.getValue(1, 0) << " " << m.getValue(1, 1);
}

// to coś robi
// wiadomo co
bool Macierz::operator==(const Macierz& m) const {
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            if (this->macierz[i][j] != m.getValue(i, j)) {
                return false;
            }
        }
    }
    return true;
}

Macierz & Macierz::operator= (const Macierz &m) {
    return *this;
}


// to jeszcze dokoncze ;p
// tą metodę do mnożenia znalazłem w necie bo Ty spałaś a ja się zbyt dobrze bawiłem xD zaraz ją przetestuję
Macierz Macierz::operator* (const Macierz &m) const {
    Macierz wynik;

    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            wynik.setValue(i, j, 0);
            for (int k = 0; k < SIZE; k++)
                wynik.setValue(i, j, wynik.getValue(i, j) + (wynik.getValue(i, k) * m.getValue(k, j)));

        }
    }

    return wynik;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Macierz.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include "stdafx.h"
#include <string>
#include "Macierz.h"


int main()
{
    try {
        Macierz *m = new Macierz();
        Macierz *m2 = new Macierz();
        m->setValue(1, 1, 2.0);
        m->wypisz();
        std::cout << *m << std::endl;
        m = m2;

        if (m == m2) {
            std::cout << "Macierz m oraz m1 sa takie same\n";
        }
        else
        {
            std::cout << "Macierze sa rozne\n";
        }

        delete m;

    }
    catch (std::exception e) {
        throw e.what();
    }
    getchar();
    return 0;
}