C++ operator overloading in a derived class - c++

Question

I have a template class matrix and I try to override the + operation for different matrix. I want to override the operator in a derived class but have a few errors. In other words, I want to be able to do only A+B for 2 defined objects of matrix and not to to do a for loop.
Here is the code:
#include<iostream>
using namespace std;
template<class T>
class matrix
{
protected:
T **tab;
int row,col;
public:
matrix(int row,int col)
{
this->row = row;
this->col = col;
tab = new T* [col];
for(int i = 0; i < col; i++)
tab[i] = new T[row];
tab[0][0] = 100;
}
T& operator()(int i,int j)
{
return tab[i][j];
}
T operator()(int i,int j)const
{
return tab[i][j];
}
void operator=(const matrix& that)
{
for(int i = 0; i < col ; i++)
for(int j = 0; j < row ; j++)
tab[i][j] = that.tab[i][j];
}
matrix(const T& tab)
{
row = tab.row;
col = tab.col;
tab = new T* [col];
for(int i = 0; i < col; i++)
tab[i] = new T[row];
}
~matrix()
{
for(int i = 0; i < col; i++)
delete tab[i];
delete tab;
}
};
template<class T>
class Operations: public matrix<T>
{
T& operator+(matrix& tab1,matrix& tab2)
{
int i,j;
ligne = tab.ligne;
col = tab.col;
tab3 = new T* [col];
for(int i = 0; i < col; i++)
tab3[i] = new T[ligne];
for(i = 0; i < col; i++)
for(j = 0; j < ligne; j++)
tab3[i][j] = tab1[i][j]+tab2[i][j];
return tab3;
}
};
int main()
{
matrix<int> tab1(10,10);
matrix<int> tab2(5,5);
cout<<tab1(0,0)<<endl;
tab1(0,0) = 10;
cout<<tab2(0,0)<<endl;
tab2(0,0) = 5;
tab2 = tab1;
tab1(0,0) = 3;
return 0;
}
The class matrix works fine. It is when I added the Operations class that I got the following erros:
v2.cpp:65:15: error: declaration of ‘operator+’ as non-function
T& operator+(matrix& tab1,matrix& tab2)
^
v2.cpp:65:13: error: expected ‘;’ at end of member declaration
T& operator+(matrix& tab1,matrix& tab2)
^
v2.cpp:65:21: error: expected ‘)’ before ‘&’ token
T& operator+(matrix& tab1,matrix& tab2)
Can you please explain me the reason for those errors and how to correct them?
Thank you
EDIT
I'd like to implement the + operator as a member class function in the matrix, but I am getting an error message: Can you please tell me what is going wrong with the way I define operator+?
matrix operator+(const matrix& that)const
{
int i,j;
T** tab3;
tab3 = new T* [col];
for(int i = 0; i < col; i++)
tab3[i] = new T[row];
for(i = 0; i < col; i++)
for(j = 0; j < row; j++)
tab3[i][j] = that.tab[i][j]+tab[i][j];
return tab3;
}

Answer 1

operator+() is normally expected to either be a member of the class it acts on (and accept one argument) or be a non-member that accepts two arguments.
For example;
class matrix
{
public:
matrix operator+(const matrix &) const; // member version
};
or
class matrix
{
public:
friend matrix operator+(const matrix &, const matrix &);
};
matrix operator+(const matrix &, const matrix &);
Note that friendship is optional in the second case, if the matrix provides public member functions that the operator+() needs.
The two approaches cannot be mixed. If the compiler encounters a class with both forms of operator+(), it has no basis to prefer calling one over the other, and will reject code like c = a+b due to ambiguity.
It is not also possible for another class (like your Operations) to provide a non-static member function operator+() that accepts two arguments of type matrix. The error message you are getting about a "non-function" is referring to that (albeit the compiler vendor has used rather cryptic wording for the error message).
Also note that operator+() should generally return by value, rather than returning a reference. Returning a reference usually causes expression like c = a+b to work differently than expected - and (depending on what reference is returned) can cause the caller to exhibit undefined behaviour.

Answer 2

I think you're just supposed to overload the + operator for the matrix class
matrix& operator+(matrix& other){
....
}
You can therefor use it like :
matrix<type> a;
// initialise a
matrix<type> b;
// initialise b
matrix<type> c = a+b; // a+b <=> a.operator+(b);