Unexpected results from calculating matrix addition using overloaded + and - operator functions within classes

[Shishykish]

Hello,

I am testing the overloaded + and operator and get some strange output in this form. I should get 3s but only the first element is calculated. Any ideas? I am just totally lost. When I test the overloaded - operator I get only -1 for the first element and nothing more.

{1, 1,
1, 1,
}
{2, 2,
2, 2,
}
{0, 0,
0, 0,
}
{3, 0,
0, 0,
}

Main

#include <iostream>
#include "Header.h"

using namespace std;

int main()
{
    Matrix x(1.0);
    Matrix y(2.0);
    Matrix z(0.0);
    Matrix a(0.0);
    x.Print();
    y.Print(); 
    z.Print();

    z = (x + y);
    z.Print();

    a = y - x;
    a.Print();

    //x.~Matrix();
    //y.~Matrix();

    return 0;
}

}

Header.h

#include <iostream>
#include <cmath>

using namespace std;

class Matrix
{
public:
	Matrix();
	Matrix(const Matrix&);
	Matrix(double);
	Matrix(Matrix&, int);

	void Print();
	double Det(Matrix&);
	Matrix InvMat(Matrix&);
	Matrix& Multiply(Matrix&, double);
	~Matrix();
	//void MatrixInput(Matrix**);

	Matrix operator=(const Matrix&);
	Matrix operator-() const;
	Matrix operator+(const Matrix&) const;
	Matrix operator-(const Matrix&) const ;

private:
	double** Arr;
	int mi = 2;
	int mj = 2;
};

//Constructor to dynamically allocate memory for the matrix and initialise values to 0.0.
//1. An overridden default constructor that initialises all entries of the matrix to zero.
Matrix::Matrix()
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}
}

Matrix::Matrix(double x)
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			Arr[i][j] = x;
		}
	}
}

Matrix::~Matrix()
{
	for (int i = 0; i < mi; ++i)
	{
		delete[] Arr[i];
	}
	delete[] Arr;
}

//2. An overridden copy constructor.
Matrix::Matrix(const Matrix& copyArr)
{
	Arr = new double* [2];

	for (int x = 0; x < 2; x++)
	{
		Arr[x] = new double[2];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = copyArr.Arr[r][c];
		}
	}
}

/*3. A constructor that specifies the four entries of the matrix and
allocates these entries appropriately*/
Matrix::Matrix(Matrix& m, int n)
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			cout << "What is the value to go in element [" << i << "]" << "[" << j << "]" << endl;
			cin >> Arr[i][j];
		}

	}
}

void Matrix::Print()
{
	cout << "{";
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			cout << Arr[i][j] << ", ";
		}
		cout << endl;
	}
	cout << "}" << endl;
}

/*4. A method(function) that returns the determinant of the matrix.*/
double Matrix::Det(Matrix& m)
{
	double det = 0.0;

	det = (m.Arr[0][0] * m.Arr[1][1]) - (m.Arr[0][1] * m.Arr[1][0]);

	return det;
}

/*5. A method that returns the inverse of the matrix, if it exists.*/
/*In other words: swap the positions of a and d, put negatives in front
of b and c, and divide everything by the determinant (ad-bc).*/
Matrix Matrix::InvMat(Matrix& m)
{
	m.Arr[0][0] = m.Arr[1][1];
	m.Arr[0][1] = -1 * m.Arr[0][1];
	m.Arr[1][0] = -1 * m.Arr[1][0];

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			m.Arr[i][j] = m.Arr[i][j] / Det(m);
		}
	}
	return m;
}

/*9. A method that multiplies a matrix by a specified double precision floating point variable.*/
Matrix& Matrix::Multiply(Matrix& m, double x)
{
	Matrix M(0.0);

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			M.Arr[i][j] = m.Arr[i][j] * x;
		}
	}
	return *this;
}

/*6. Overloading of the assignment operator, allowing us to write code such as A = B; for
instances of the
class Aand B.*/
Matrix Matrix::operator=(const Matrix& m)
{
	for (int i = 0; i < 1; i++)
	{
		for (int j = 0; j < 1; j++)
		{
			Arr[i][j] = m.Arr[i][j];
		}
	}
	return *this;
}

/*7. Overloading of the unary subtraction operator, allowing us to write code such as A = -B;
for instances
of the class Aand B.*/
Matrix Matrix::operator-() const
{
	Matrix m(0.0);
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			m.Arr[i][j] = -Arr[i][j];
		}
	}
	return m;
}

/*8. Overloading of the binary addition and subtraction operators, allowing us to write code
such as A = B + C; or A = B - C; for instances of the class A, Band C.*/
Matrix Matrix::operator+(const Matrix& oldM) const
{
	Matrix newM(0.0);

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			newM.Arr[i][j] = Arr[i][j] + oldM.Arr[i][j];
		}
	}
	return newM;
}

Matrix Matrix::operator-(const Matrix& x) const 
{
	Matrix Arr(0.0);

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			Arr.Arr[i][j] = Arr.Arr[i][j] - x.Arr[i][j];
		}
	}
	return Arr;
}

[MikeyBoy]

In your overloaded assigment operator, each loop only ever iterates once, so you only ever assign the [0, 0] cell of the new matrix.

EDIT: This is a perfect example of why it's a good idea to define and use well-named constants, rather than scattering your code with magic numbers.

[Ganado]

Also, in your - (minus) operator logic, you never use the class's Arr.
This is why naming is important; you can reduce confusion by not having two things called "Arr".

Matrix retMatrix(0.0);
// ...
        retMatrix.Arr[i][j] = Arr[i][j] - x.Arr[i][j];
// ...
return retMatrix;

[Shishykish]

@Ganado

Feel like a bloody pirate in a while loop repeating the letter "r"

@MikeyBoy

You're right, I was intending to be consistent with using mi and mj, but I think in my seeking to review the errors, that went out the window as I was trying too many things at once. I have since used them for the intended purpose, limits for all the for loops

Thanks very much. It is working a treat now. Here it is

Main

#include <iostream>
#include "Header.h"

using namespace std;

int main()
{
    Matrix x(1.0);
    Matrix y(2.0);
    Matrix z(0.0);
    Matrix a(0.0);
    Matrix b(0.0);
    Matrix c(0.0);

    z = (x + y);
    z.Print();

    a = y - x;
    a.Print();

    y.Multiply(5.0);
    y.Print();

    b.MatrixInput();
    b.Print();
    c = b.InvMat(b);
    b.Print();
    c.Print();
    //x.~Matrix();
    //y.~Matrix();

    return 0;
}

Header

#include <iostream>
#include <cmath>

using namespace std;

class Matrix
{
public:
	Matrix();
	Matrix(const Matrix&);
	Matrix(double);
	Matrix(Matrix&, int);

	void Print();
	double Det(Matrix&);
	Matrix InvMat(Matrix&);
	void Multiply(double);
	~Matrix();
	void MatrixInput();

	Matrix operator=(const Matrix&);
	Matrix operator-() const;
	Matrix operator+(const Matrix&) const;
	Matrix operator-(const Matrix&) const;

private:
	double** Arr;
	int mi = 2;
	int mj = 2;
};

//Constructor to dynamically allocate memory for the matrix and initialise values to 0.0.
//1. An overridden default constructor that initialises all entries of the matrix to zero.
Matrix::Matrix()
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}
}

Matrix::Matrix(double x)
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			Arr[i][j] = x;
		}
	}
}

Matrix::~Matrix()
{
	for (int i = 0; i < mi; ++i)
	{
		delete[] Arr[i];
	}
	delete[] Arr;
}

//2. An overridden copy constructor.
Matrix::Matrix(const Matrix& copyArr)
{
	Arr = new double* [2];

	for (int x = 0; x < 2; x++)
	{
		Arr[x] = new double[2];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = copyArr.Arr[r][c];
		}
	}
}

/*3. A constructor that specifies the four entries of the matrix and
allocates these entries appropriately*/
Matrix::Matrix(Matrix& m, int n)
{
	Arr = new double* [mi];

	for (int x = 0; x < mi; x++)
	{
		Arr[x] = new double[mj];
	}

	for (int r = 0; r < mi; r++)
	{
		for (int c = 0; c < mj; c++)
		{
			Arr[r][c] = 0.0;
		}
	}

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			cout << "What is the value to go in element [" << i << "]" << "[" << j << "]" << endl;
			cin >> Arr[i][j];
		}

	}
}

void Matrix::Print()
{
	cout << "{";
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			cout << Arr[i][j] << ", ";
		}
		cout << endl;
	}
	cout << "}" << endl;
}

/*4. A method(function) that returns the determinant of the matrix.*/
double Matrix::Det(Matrix& m)
{
	double det = 0.0;

	det = (m.Arr[0][0] * m.Arr[1][1]) - (m.Arr[0][1] * m.Arr[1][0]);

	return det;
}

/*5. A method that returns the inverse of the matrix, if it exists.*/
/*In other words: swap the positions of a and d, put negatives in front
of b and c, and divide everything by the determinant (ad-bc).*/
Matrix Matrix::InvMat(Matrix& m)
{
	m.Arr[0][0] = m.Arr[1][1];
	m.Arr[0][1] = -1 * m.Arr[0][1];
	m.Arr[1][0] = -1 * m.Arr[1][0];

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			m.Arr[i][j] = m.Arr[i][j] / Det(m);
		}
	}
	return m;
}

/*9. A method that multiplies a matrix by a specified double precision floating point variable.*/
void Matrix::Multiply(double x)
{
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			Arr[i][j] = Arr[i][j] * x;
		}
	}
}

void Matrix::MatrixInput()
{
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			cout << "What would you like element (" << i << ", " << j << ")" << "to be?" << endl;
			cin >> Arr[i][j];
		}
	}
}

/*6. Overloading of the assignment operator, allowing us to write code such as A = B; for
instances of the
class Aand B.*/
Matrix Matrix::operator=(const Matrix& m)
{
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			Arr[i][j] = m.Arr[i][j];
		}
	}
	return *this;
}

/*7. Overloading of the unary subtraction operator, allowing us to write code such as A = -B;
for instances
of the class Aand B.*/
Matrix Matrix::operator-() const
{
	Matrix m(0.0);
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			m.Arr[i][j] = -Arr[i][j];
		}
	}
	return m;
}

/*8. Overloading of the binary addition and subtraction operators, allowing us to write code
such as A = B + C; or A = B - C; for instances of the class A, Band C.*/
Matrix Matrix::operator+(const Matrix& oldM) const
{
	Matrix newM(0.0);

	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			newM.Arr[i][j] = Arr[i][j] + oldM.Arr[i][j];
		}
	}
	return newM;
}

Matrix Matrix::operator-(const Matrix& x) const
{
	Matrix retMatrix(0.0);

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			retMatrix.Arr[i][j] = Arr[i][j] - x.Arr[i][j];
		}
	}
	return retMatrix;
}