C++ error: Passing 'const' as 'this' array - c++

Question

I am getting passing 'const Array' as 'this' argument of 'int& Array::operator[](int)' discards qualifiers when compiling under Dev C++. If I compile using gcc on cygwin I've got a few error messages of this type:
error: extra qualification ‘Array::’ on member ‘Array’ [-fpermissive]
Can you tell me what is the reason for the error? I've spent a lot of time on this code and still can't make it work correctly.
#include<iostream>
using namespace std;
class Array
{
int *m_ptr;
int m_size;
public:
Array(int sz)
{
cout<<"constructor\n";
m_size = sz;
m_ptr = new int[sz];
}
~Array()
{
cout<<"Delete\n";
delete[] m_ptr;
}
int& operator[] (int j)
{
cout<<"Operation []\n";
return m_ptr[j];
}
void Array::copy(const Array& ar)
{
m_size = ar.m_size;
m_ptr = new int[m_size];
int *ptr = ar.m_ptr;
int j;
for(j = 0;j < m_size; j++)
m_ptr[j] = ptr[j];
}
Array::Array(const Array& ar)
{
copy(ar);
}
void Array::print(const Array& ar)
{
int i;
int len = ar.m_size;
for(i = 0;i < len;i++)
cout<<ar[i]<<" ";
cout<<endl;
}
};
int main()
{
Array a1(10);
Array a2(5);
int i;
for(i = 0;i < 10;i++)
{
a1[i] = 1;
if(i < 5) a2[i] = 2;
}
print(a1);
return 0;
}
Furthermore, the book I am reading also has the function
Array& operator= (const Array& ar)
{
delete m_ptr;
copy(ar);
return *this;
}
I do not understand why do we need to use this function.

Answer 1

Just change
void Array::copy(const Array& ar)
to
void copy(const Array& ar)
The class scope qualifier is only needed for function definitions appearing outside of the class declaration.

Answer 2

Issue 1
You don't need the Array:: in
void Array::copy(const Array& ar) { ... }
when the function is defined inside the class definition. It can simply be
void copy(const Array& ar) { ... }
You need the Array:: part only when the function is defined outside the class definition.
Issue 2
In print, you have the line:
cout<<ar[i]<<" ";
Since ar is a const object and the operator[]() function is not a const member function, the compiler doesn't like it. What you should do is provide two overloads of the operator[] function -- one for const objects and one for non-const objects.
int& operator[] (int j)
{
return m_ptr[j];
}
int operator[] (int j) const
{
return m_ptr[j];
}
Then, you can use the array operator to access the elements of a const object as well as access and modify the elements of a non-const object.