Classes with overloading operators

[Mannah]

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

class Matrix
{
  friend ostream& operator<<(ostream output&, const Matrix&);
  friend istream& operator>>(istream input&, Matrix&);
 
public :
 Matrix( int c, int r); //default constructor
 ~Matrix(); //destructor
 Matrix( const Matrix & M); //copy constructor
  void setMartix( int c, int r); //function for setting the 2D matrix
  int getMatrix(); //function to return the matrix
  void Setrows( int r);
  void Setcols( int c);
  int Getcols();
  int Getrows();
  void Print();
 
 Matrix operator +( const Matrix& M);
 Matrix operator -( const Matrix& M);
 Matrix operator *( const Matrix& M);
 Matrix operator +=( int Matrix& M);
 Matrix& operator -();//negation
 Matrix& operator =( const Matrix& M);

 Matrix& operator ++(); //pre-increment
 Matrix& operator ++( int ignoreMe); //post-increment
 Matrix& operator --(); //pre-decrement
 Matrix& operator --( int ignoreMe); //post decrement
 
 int & operator ()(int row, int cols);
 const int & operator ()(int rows, int cols)const;
 bool   operator ==( const Matrix& M);

private :
  int **array2D;
  int rows,cols;
};
 
#endif 

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

Matrix::Matrix( int c, int r) //default constructor
{ 
 rows = r;
 cols = c;
 array2D= new   int *[rows];//allocating memory
  for ( int i = 0; i < rows; i++)
 {
   array2D[i] = new   int [cols];
    for ( int j=0; j < cols; j++)
   {
     array2D[i][j]=0;
   }
 }
}

Matrix::Matrix( const Matrix & M) //copy constructor
{
 rows = M.rows;
 cols = M.cols;
 array2D= new int *[rows];
  for ( int i = 0; i < rows; i++)
 {
   array2D[i] = new   int [cols];
    for ( int j=0; j < cols; j++)
   {
     array2D[i][j] = M.array2D[i][j];
   }
 }
}
Matrix::~Matrix() //destructor
{ //deleteing memory to prevent memory leak
  for ( int i = 0; i < rows; ++i)
    delete [] array2D[i];
 
  delete [] array2D;
}
void Matrix::Setcols( int c) //set column
{
 cols = c;
}
 
void Matrix::Setrows( int r) //set rows
{
 rows = r;
}
int Matrix ::Getcols() //get cols
{
  return cols;
}
int Matrix ::Getrows() //get rows
{
  return rows;
}
bool Matrix:: setMatrix(int value)
{
        for(int i=0;i<rows;i++)
        {
                for(int j=0;j<cols;j++)
                {
                        array2D[i][j] = value;
                        return true;
                }
        }
        return false;
}

bool Matrix:: getArr( int & value)
{
        for(int i=0;i<rows;i++)
        {
                for(int j=0;j<cols;j++)
                {
                        value = array2D[i][j];
                        return true;
                }
        }
        return false;
}
void Matrix::Print() //print matrix
{
 cout<< "The Matrix : " ;
  for ( int i =0;i<rows;i++)
    for ( int j=0;i<cols;j++)
     cout<<array2D[i][j];
}
bool Matrix::operator==(const Matrix &M)
{
        if(this->rows!=M.rows)
                return(false);
        if(this->cols!=M.cols)
                return(false);
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        if(this->array2D[i][j]!=M.array2D[i][j])
                                return(false);
                }
        }
        return(true);
}
Matrix& Matrix::operator=(const Matrix& M)
{
        if(this==&M)
                return(*this);
        delete [] array2D;
        this->rows=M.rows;
        this->cols=M.cols;
        this->array2D = new int*[rows];
        for (int i=0; i<rows; i++)
        {
                this->array2D[i] = new int[cols];
                for(int j=0;j<cols;j++)
                {
                        this->array2D[i][j]=M.array2D[i][j];
                }
        }
        return(*this);

}
Matrix Matrix::operator+(const Matrix & M)
{
        Matrix x(*this);
        if(this->cols!=M.cols)
                exit(1);
        if(this->rows!=M.rows)
                exit(1);
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        x.array2D[i][j] = x.array2D[i][j]+M.array2D[i][j];
                }
        }
        return(x);
}
Matrix Matrix::operator-(const Matrix & M)
{
        Matrix x(*this);
        if(this->cols!=M.cols)
                exit(1);
        if(this->rows!=M.rows)
                exit(1);
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        x.array2D[i][j] = x.array2D[i][j]-M.array2D[i][j];
                }
        }
        return(x);
}
Matrix& Matrix::operator-()//Negate; unary op
{
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        array2D[i][j] = -array2D[i][j];
                }
        }
        return(*this);
}
Matrix& Matrix::operator++()//Post increment 
{
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        array2D[i][j]+=1;
                }
        }
        return (*this);
}
Matrix& Matrix::operator++(int ignoreMe)//Post increment 
{
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        array2D[i][j]++;;
                }
        }
        return (*this);
}
int & Matrix::operator()(int row, int col)//lvalue; return array2D[row][col];
{
        if(row<= 9 || row>=0 && cols<=9 || cols>=0)
                return(array2D[rows][cols]);
}
const int & Matrix::operator()(int row, int col) const//rvalue; return// array2D[row][col];
{
        if(row<=9 || row>=0 && cols<=9 || cols>=0)
                return(array2D[rows][cols]);
}
Matrix& Matrix:: operator*(const Matrix &M)
{
        for (int i=0; i<rows; i++)
        {
                for(int j=0;j<cols;j++)
                {
                        array2D[i][j] = array2D[i][j]*M.array2D[i][j];
                }
        }
        return(*this);
}

Matrix& Matrix::operator+=(const Matrix &M)
{
	for(int i=0;i<rows.i++)
	{
		for(int j=0;j<cols;j++)
		{
			array2D[i][j]+=M.array2D;

		}
	}
	return (*this);
}

ostream & operator <<(ostream & output, const Matrix& M)
{
        for (int i=0; i<M.rows; i++)
        {
                for(int j=0;j<M.cols;j++)
                {
                        output<<M.array2D[i][j]<<" ";
				}

        }
        return output;
}

istream & operator >>(istream & input, const Matrix & M)
{
        for (int i=0; i<M.rows; i++)
        {
                for(int j=0;j<M.cols;j++)
                {
                        input>>M.array2D[i][j];
                }
        }
        return input;
}

can anyone help me figure out whts wrong ??

[TheDestroyer]

If this code compiles:

1- Have you ever heard about something called a debugger?
2- Debug your code and tell us where the error happens, and what you expect.

If this code doesn't compile:

1- Tell us where the error happens, point it out in the code.
2- Tell us what the error says exactly.


Put yourself in our shoes and imagine these 1000 lines in front of you... what do you expect us to do?????

[guestgulkan]

The code as given does not compile - there are quie a few syntax errors, spelling errors (where the word Matrix is missspelt), and function redeclaration
errors (function definitions different from function declaration)