How can I fix these memory access violations?

[Shishykish]

Hello

Currently I am making a piece of code to perform some some matrix maths. I keep getting access violations from lines 101 and 204. Have implemented them both incorrectly?

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&);
	Matrix& Multiply(Matrix&,double);
	~Matrix();
	//void MatrixInput(Matrix**);

	Matrix operator=(Matrix);
	Matrix& operator-(Matrix&);
	friend Matrix& operator+(Matrix&, Matrix&);
	friend Matrix& operator-(Matrix&, Matrix&);

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 M;
}

/*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=(Matrix m)
{
	Matrix M(0.0);
	for (int i = 0; i < 1; i++)
	{
		for (int j = 0; j < 1; j++)
		{
			M.Arr[i][j] = m.Arr[i][j];
		}
	}
	return M;
}

/*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-(Matrix& m)
{
	for (int i = 0; i < mi; i++)
	{
		for (int j = 0; j < mj; j++)
		{
			Arr[i][j] = -1 * m.Arr[i][j];
		}
	}
	return *this;
}

/*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& operator+(Matrix& x, Matrix& y)
{
	Matrix Arr(0.0);

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

Matrix& operator-( Matrix& x, Matrix& y)
{
	Matrix Arr(0.0);

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

Main

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

using namespace std;

int main()
{
    Matrix x(1);
    Matrix y(2);
    Matrix z(0.0);

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

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

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

    return 0;
}

[Peter87]

I get the following warning in Multiply, operator+ and operator-.

GCC wrote:

warning: reference to local variable ‘M’ returned

warning: reference to local variable ‘Arr’ returned

If your compiler doesn't warn you about these things you should consider turning on more warnings. With GCC you should at least use -Wall but -Wextra is also helpful. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html

[Shishykish]

@Peter87

That's really strange, didn't get these at all! I am using Visual Studio 2019.

[Thomas1965]

On Visual Studio you should set the warning level to W3
Project->Properties->Configuration->C++->General

[andywestken]

W4 would be even better.

Andy

[Shishykish]

Hello,

I have reapplied the choice.

[Shishykish]

Hi, So I have reduced it to 1 warning of

C4172	returning address of local variable or temporary: newM			256	

Then I have

Exception thrown: read access violation.

Line 221

Well they must be linked since in int main I have

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

#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;
}

[Peter87]

I have reduced it to 1 warning

Why not reduce it down to zero?

[Shishykish]

With this now yes. Now it's just the read violation

#pragma once
#pragma once


#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;
}

[coder777]

Your operator+(...) is still returning a reference to a local variable.

[Shishykish]

Hello,

I did see this appear earlier, but for some reason it doesn't come up. Are a build it does appear now after I reset the warnings level, given earlier in the thread. What would be a better implementation of this overloaded operator?

[dhayden]

Just like operator-(), operator+() should return a Matrix, not a Matrix &

[Shishykish]

Awesome! That has solved the issue.