przeciążanie operatorów, zapis kodu

Cześć, mam pytanie, czym się różnią te dwie linijki kodu:

• int& operator()(int k, int n)
• Macierz operator+(const Macierz& obj)

chciałem ta pierwsza zapisać tak: Macierz operator()(const Macierz& obj(k,n)), ale wtedy jest błąd, dlaczego?

tu cały kod:

#include <iostream>
#include <string>

using namespace std;

class Macierz {
public:
    int macierz[3][3];

    void Drukuj()
    {
        for(int i = 0; i<3; i++)
        {
            for(int j = 0; j<3; j++)
            {
                cout.width(5);
                cout << macierz[i][j];
            }
            cout << endl;
        }
        cout << endl;
    }

    int& operator()(int k, int n)
    {
        return macierz[k][n];
    }

    Macierz operator+(const Macierz& obj)
    {
        Macierz m_tmp;
        for(int i = 0; i<3; i++)
        {
            for(int j = 0; j<3; j++)
            {
                m_tmp.macierz[i][j] = macierz[i][j] + obj.macierz[i][j];
            }
        }

        return m_tmp;
    }

    Macierz operator*(const Macierz& obj)
    {
       Macierz m_tmp;
       for(int i = 0; i<3; i++)
       {
           for(int j = 0; j<3; j++)
           {
               m_tmp.macierz[i][j] = 0;
           }
       }
       for(int k = 0; k<3; k++)
       {
           for(int j = 0; j<3; j++)
           {
               for(int i = 0; i<3; i++)
               {
                   m_tmp.macierz[k][j] += macierz[k][i] * obj.macierz[i][j];
               }
           }
       }
       return m_tmp;
    }

    Macierz(int m[3][3])
    {
        for(int i = 0; i<3; i++)
        {
            for(int j = 0; j<3; j++)
            {
                macierz[i][j] = m[i][j];
            }
        }
    }

    Macierz()
    {
    }
};

void zadanie3()
{
    int macierz1[3][3] = {{3, 2, 3}, {7, 5, 6}, {2, 4, 9}};
    int macierz2[3][3] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};

    Macierz m1(macierz1);
    Macierz m2(macierz2);

    Macierz m3 = m1 + m2;
    Macierz m4 = m1 * m2;
    m1.Drukuj();
    m2.Drukuj();
    m3.Drukuj();
    m4.Drukuj();
}

void zadanie4()
{
    Macierz obj;
    int start = 1;
    for(int i = 0; i<3; i++)
    {
        for(int j = 0; j<3; j++, start+=2)
        {
            obj(i,j) = start;
        }
    }

    for(int i = 0; i<3; i++)
    {
        for(int j = 0; j<3; j++)
        {
            cout.width(3);
            cout << obj(i,j);
        }
        cout << endl;
    }
}



int main()
{
    cout << "Zadanie 3:\n";
    zadanie3();
    cout << "Zadanie 4:\n";
    zadanie4();
    return 0;
}

i jeszcze polecenie zadania:
3. (25%) Przeciążanie podstawowych operatorów

Stwórz klasę, która posiada publiczne:
• pole macierz – tablicę dwuwymiarową 3x3.
• Metodę Drukuj(), która drukuje macierz na ekranie.
• metodę przeciążoną operator+, aby dodając obiekty tej klasy, macierz obiektu wynikowego była wynikiem sumy macierzy.
obj3 = obj1 + obj2;
• metodę przeciążoną operator*, aby dodając obiekty tej klasy, macierz obiektu wynikowego była wynikiem iloczynu macierzy.
obj4 = obj1 * obj2;
W głównym kodzie:
• Zadeklaruj 2 obiekty tej klasy.
• W każdym obiekcie wypełnij macierze przykładowymi wartościami
(możesz stworzyć konstruktor do tego celu).
• Stwórz obiekt nr 3, będący sumą (macierzy) obiektu1 i obiektu2.
Oczywiście wykorzystaj operator+. obj3 = obj1 + obj2;
• Stwórz obiekt nr 4, będący iloczynem (macierzy) obiektu1 i obiektu2.
Oczywiście wykorzystaj operator*. obj4 = obj1 * obj2;
• Wydrukuj wszystkie obiekty (ich macierze) na ekranie.
Dodawanie macierzy:
Mnożenie macierzy:

4. (25%) Przeciążanie operatorów zaawansowane
   Rozbuduj klasę z poprzedniego zadania
   przeciąż operator(),
   Czyli zamiast:

obj.macierz[ 1 ][ 1 ] = 999;

uzyskamy coś takiego:

obj( 1, 1 ) = 999;

W głównym kodzie: stwórz obiekt klasy,

• ustaw komórki macierzy, z użyciem przeciążonego operatora. Zapewne
  będzie trzeba użyć dwóch pętli.
• wydrukuj macierz na ekranie. Nie używaj metody Drukuj(), tylko dostań się do elementów z wykorzystaniem przeciążonego operatora. Zapewne będzie trzeba użyć dwóch pętli.

Cześć, mam pytanie, czym się różnią te dwie linijki kodu:
int& operator()(int k, int n)
Macierz operator+(const Macierz& obj)

Mniej więcej tym czym różni się wiertarka od łopaty. To zupełnie różne rzeczy. Z jakiego kursu/książki korzystasz, że nie jest to tam wytłumaczone?

pierwsze to akcesor do elementów macierzy, drugie to operator sumowania macierzy.

Tak to ujmuje GPT (wygląda poprawnie):

Cześć!

Pierwsza linijka kodu int& operator()(int k, int n) to przeciążenie operatora nawiasów okrągłych (), który pozwala na dostęp do elementów macierzy przez zwrócenie referencji do odpowiedniego elementu.

Druga linijka kodu Macierz operator+(const Macierz& obj) to przeciążenie operatora dodawania +, który pozwala na dodanie dwóch obiektów klasy Macierz i zwrócenie nowego obiektu, którego macierz jest sumą macierzy obu obiektów.

Co do Twojego pytania o pierwszą linijkę kodu, próbujesz zdefiniować operator nawiasów okrągłych w sposób, który nie jest poprawny. Operator nawiasów okrągłych oczekuje dwóch argumentów typu int, natomiast Ty próbujesz przekazać jeden argument typu const Macierz&, co powoduje błąd kompilacji.

Mam nadzieję, że odpowiedziałem na Twoje pytanie i pomogłem zrozumieć różnice między tymi dwoma linijkami kodu!