Subscript requires array or pointer type

//Matrix.h
#include <iostream>
#include <stdlib.h>
using namespace std;
class Matrix
{
        friend istream& operator >>(istream& , const Matrix&Arr);
        friend ostream& operator <<(std::ostream&, const Matrix&Arr); 
        int*ptr;
        int size;
public:
        Matrix(int s=10);
       Matrix(Matrix &arr);
        virtual~Matrix();
 
        void Rindomize(int num = 10);
        Matrix &operator-(Matrix &arr);
        Matrix &operator=(Matrix &arr);
        Matrix &operator-=(Matrix &arr);
        Matrix &operator*=(Matrix &arr);
        
};

//Matrix.cpp
#include "Matrix.h"
 
Matrix::Matrix(int s)
{
        size=s;
        int **ptr = new int *[size];  
        for (int i = 1; i <= size; i++ )
            {
                  if ((ptr[ i ] = new int [size]) == NULL) 
                  cout << "Error\n";
            }
 
         for(int i = 0; i < size; i++)
            for(int j=0; j<size; j++)
        {
                ptr[i][j] = 0;
        }
        cout << "Constructor" << endl;
}
//--------------------------------------------------------------------------------
Matrix::Matrix(Matrix& arr)
{ 
        size = arr.size;
        int **ptr = new int *[size];  
        for (int i = 1; i <= size; i++ )
            {
                  if ((ptr[ i ] = new int [size]) == NULL) 
                  cout << "Error\n";
        }
                 for(int i = 0; i < size; i++)
            for (int j=0; j<size; j++)
        {
                ptr[i][j] = arr.ptr[i][j];
                
        }
        
        cout << "Copy Constructor" << endl;
}
//--------------------------------------------------------------------------------
Matrix::~Matrix()
{
        delete[] ptr;
        cout << "Destructor" << endl;
}
//--------------------------------------------------------------------------------
void Matrix::Rindomize(int num)
{       
        for(int i = 0; i < size; i++)
            for(int j=0; j<size; j++)
        {
                ptr[i][j] = rand() % num;
        }       
}
//--------------------------------------------------------------------------------
ostream& operator <<(ostream& output, const Matrix& Arr)
{
    for(int i=0; i<Arr.size; ++i)
        for(int j=0; j<Arr.size; j++)
        output<<Arr.ptr[i][j]<<" ";
    return output; 
}
//--------------------------------------------------------------------------------
istream& operator >>(istream& input, const Matrix& Arr)
{
    for (int i=0; i<Arr.size; i++)
        input>>Arr.ptr[i];
    return input;
}
//--------------------------------------------------------------------------------
Matrix& Matrix::operator-=(Matrix& arr) 
{
        int mins = (size < arr.size) ? size : arr.size;         
       Matrix temp;
        if(mins == arr.size)
        {
                temp = *this;
                for(int i = 0; i < mins; i++)
                    for (int j=0; j<mins; j++)
                {               
                        temp.ptr[i][j] -= arr.ptr[i][j];
                }
        }
        else
        {       
                temp = arr;
                for(int i = 0; i < mins; i++)
                    for(int j=0; j<mins; j++)
                {               
                        temp.ptr[i][j] -= ptr[i][j];
                }               
        }
        cout << "Operator -=" << endl;
        return temp;
}
 
//--------------------------------------------------------------------------------
Matrix&Matrix::operator= (Matrix & arr)
{
        if(this != &arr)
        {
                delete[] ptr;
                size = arr.size;
                ptr = new int[size];
                for(int i = 0; i < size; i++)
                {
                        ptr[i] = arr.ptr[i];
                }
        }
        cout << "Operator =" << endl;
        return *this;
}
 
//--------------------------------------------------------------------------------
Matrix&Matrix::operator*=(Matrix &arr)
{
    int **tmp = new int *[size];  
        for (int i = 1; i <= size; i++ )
            {
                  if ((tmp[ i ] = new int [size]) == NULL) 
                  cout << "Error\n";
            }
         temp = *this;
                for(int i = 0; i < size; i++)
                    for (int j=0; j<size; j++)
                {               
                    tmp[i][j]=0;
                }
                    for(int i = 0; i < size; i++)
                    for (int j=0; j<size; j++)
                    for(int k=0; k<size; k++)
                      tmp[i][j]+= temp.ptr[i][k] * arr.ptr[k][j];
 
 
                cout<<"Operator *="<<endl;
                return tmp;
}

//main.cpp
#include "Matrix.h"
#include <conio.h>
#include <time.h>
 
int main()
{
        srand(time(0));
        Matrix a(5);
        a.Rindomize(5);
        Matrix b(7);
        b.Rindomize(5);
        Matrix c;  
        
        cout<<"HugeInt a:\n"<<a<<"\n";
        cout<<"HugeInt b:\n"<<b<<"\n";
 
        c=b;
        a*=b;
        b-=a;
        getch();
        
}