отсутствует оператор "[]", соответствующий этим операндам

Пишу класс матрицы на С++. Во время выполнения возникает 2 ошибки:

1)отсутствует оператор "[]", соответствующий этим операндам

2)бинарный "[": "const Matrix" не определяет этот оператор или преобразование к типу приемлемо к встроенному оператору

Это происходит в методе Matrix operator*(const Matrix& arr);

В чем может быть проблема?

//MAIN
#include <locale.h>
#include <iostream>

#include "Matrix.h"

using namespace std;

int main()
{
    setlocale(LC_ALL, "rus");

    Matrix A(2, 3);
    Matrix B(2, 3);
    
    

    int i, j;
    for (i = 0; i < 2; i++)
        for (j = 0; j < 3; j++)
        {
            B.SetArr(i, j, rand() % 100);
            A.SetArr(i, j, rand() % 100);
        }

    A.Print("A");
    B.Print("B");
    cout << " A+B \n" << (A + B) << endl;
    cout << " A-B \n" << (A - B) << endl;

  //  cout << " A*B \n" << (A * B) << endl;
}


//HEADER

#ifndef MATRIX_H
#define MATRIX_H
#include <iostream>
using namespace std;

class Matrix
{
public:
    Matrix();
    Matrix(int _n, int _m);
    Matrix(const Matrix& _arr);

    double GetArr(int i, int j);
    void SetArr(int i, int j, double value);
    void Print(const char* ObjName);

    Matrix operator=(const Matrix& _arr);
    Matrix operator+(const Matrix& arr);
    Matrix operator-(const Matrix& arr);
    Matrix operator*(const Matrix& arr);
    friend std::ostream& operator<<(std::ostream& os, const Matrix& arr);

    friend void swap(Matrix& first, Matrix& second);
    ~Matrix();
private:
    int n;
    int m;
    double** arr = nullptr;

};
#endif

//METHODS

#include <iostream>
#include "Matrix.h"
using namespace std;


Matrix::Matrix() // Конструктор по умолчанию
{
    n = 0;
    m = 0;
    arr = nullptr;
}




Matrix::Matrix(int _n, int _m)//Конструктор с параметрами
{

    n = _n;
    m = _m;
    arr = new double* [n];
    
    for (int i = 0; i < n; ++i)
    {
        arr[i] = new double[m] {0};
        
    }

}

Matrix::Matrix(const Matrix& _arr)
{
    n = _arr.n;
    m = _arr.m;

    arr = new double* [n];

    for (int i = 0; i < n; ++i)
    {
        arr[i] = new double[m] {0};

    }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            arr[i][j] = _arr.arr[i][j];
    
}





double Matrix::GetArr(int i, int j)
{
    if ((n > 0) && (m > 0))
        return arr[i][j];
    else
        return 0;
}

void Matrix::SetArr(int i, int j, double value)
{
    if ((i < 0) || (i >= n))
        return;
    if ((j < 0) || (j >= m))
        return;
    arr[i][j] = value;
}

void Matrix::Print(const char* Name)
{
    cout << "Матрица: " << Name << endl;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
            cout << arr[i][j] << "\t";
        cout << endl;
    }
    cout << "---------------------" << endl << endl;
}

Matrix Matrix::operator=(const Matrix& _arr)
{
    if (m > 0)
    {

        for (int i = 0; i < n; i++)
            delete[] arr[i];
    }

    if (n > 0)
    {
        delete[] arr;
    }


    n = _arr.n;
    m = _arr.m;
    


    arr = new double* [n];
    for (int i = 0; i < n; ++i)
        arr[i] = new double[m] {0};



    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            arr[i][j] = _arr.arr[i][j];
    return *this;
}


Matrix Matrix::operator+(const Matrix& arr) 
{
    if (n == arr.n && m == arr.m) 
    { 
        Matrix result(*this); // Копируем данные из *this в result (конструктор копирования)
        for (int i = 0; i < n; ++i) 
        {
            for (int j = 0; j < m; ++j)
            {
                result.arr[i][j] += arr.arr[i][j]; // В result копия данных this складывается с данными arg
            }
        }
        return result;
    }
}

Matrix Matrix::operator-(const Matrix& arr)
{
    if (n == arr.n && m == arr.m)
    {
        Matrix result(*this); // Копируем данные из *this в result (конструктор копирования)
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                result.arr[i][j] -= arr.arr[i][j]; // В result копия данных this складывается с данными arg
            }
        }
        return result;
    }
}

Matrix Matrix::operator*(const Matrix& arr)       //<---- ТУТ ВОЗНИКАЕТ ОШИБКА
{
    if (m == arr.n)
    { // Если число стб. матрицы this совпадает с числом стр. матрицы arg, то умножение возможно
        Matrix result(this->n, arr.m); // Конструктор по размерам
        for (int i = 0; i < n; ++i) 
        {
            for (int j = 0; j < arr.m; ++j) 
            {
                for (int k = 0; k < m; ++k) 
                {
                    result.arr[i][j] += (arr[i][k] * arr.arr[k][j]); //<--- А КОНКРЕТНО ТУТ в arr[i][k]
                }
            }
        }
        return result;
    }
}

ostream& operator<<(ostream& os, const Matrix& arr) {
    for (int i = 0; i < arr.n; ++i) 
    {
        os << arr.arr[i][0];
        for (int j = 1; j < arr.m; ++j) 
        {
            os << ' ' << arr.arr[i][j];
        }
        os << '\n';
    }
    return os;
}



void swap(Matrix& first, Matrix& second)  {
    std::swap(first.arr, second.arr);
    std::swap(first.m, second.m);
    std::swap(first.n, second.n);
}

Matrix::~Matrix()//Деструктор
{
    for (size_t i = 0; i < n; ++i) {
        delete[] arr[i];
    }
    delete[] arr;
}