_CrtIsValidHeapPointer Debug Assertion

[ratherthanwords]

Hi...

So I'm writing some code that does some matrix operations (namely multiplications) I've created a separate class for manipulating the matrices. The matrix itself has memory for it allocated within the class. Here's a sample of what I'm talking about...

Matrix* Matrix::multiply(const Matrix &b) {
  assert(c == b.r);
  Matrix *result = new Matrix(r, b.c);
  for (int i = 0; i < b.c; i++)
    for (int j = 0; j < r; j++)
      for (int k = 0; k < c; k++)
        result->matrix[i][j] += matrix[i][k] * b.matrix[k][j];
  return result;
}

The Constructor... Allocates a two dimensional array of type double, which can be referenced using array[i][j] notation.

Matrix::Matrix(int _r, int _c) {
  r = _r;
  c = _c;
  matrix = (double**)malloc(r*sizeof(double*));
  for (int i = 0; i < r; i++) {
    matrix[i] = (double*)malloc(c*sizeof(double));
    memset(matrix[i], 0x00, c*sizeof(double));
  }
}

The Destructor - frees allocated memory

Matrix::~Matrix() {
  for (int i = 0; i < r; i++)
    free(matrix[i]);
  free(matrix);
}

And the code that calls it...

Matrix a(3,1);
Matrix b(3,3);
Matrix *r = NULL;
 
//values fo the matrix are initialized here...
 
r = b.multiply(a);
r->print();
delete r;       //source of error...
 

So it compiles and runs under linux, and GDB doesn't catch an error, and there is no error when multipling a 3x2 by a 2x3 matrix...also, sometimes the program will exit normally (the error doesn't happen all the time, more like about 90% of the time...

I'm flustered, thanks in advance to anyone that has suggestions!

[Banfa]

I can see nothing obviously wrong, however I would not use the memory allocation technique you have.

Just because the data represents a matrix which is a 2 dimensional array does not mean you have to allocate it like that. For a 2 by 3 matrix all you actually need is space to store 6 doubles. This makes the constructor and destructor (obviously with a redefinition of matrix to type double *)

Matrix::Matrix(int _r, int _c) {
  r = _r;
  c = _c;
  matrix = (double*)malloc(r*c*sizeof(double));
  memset(matrix, 0x00, r*c*sizeof(double));
}
 
Matrix::~Matrix() {
  free(matrix);
}
 

As you can see the memory allocation is a lot simpler and has the added benafit of causing less memory fragmentation.

Next you add an inline member function in the header file a bit like

    inline int index(int i, int j) {
        return i*c+j;
    }
 

then

/* instead of */
 
matrix[i][j] = ...;
 
/* use */
 
matrix[index(i,j)] = ...;
 

This is a common technique for handling comples indexes, you can build various shape and dimension arrays this way.

On to you problem I believe it lies at least partly in this code

Matrix* Matrix::multiply(const Matrix &b) {
  assert(c == b.r);
  Matrix *result = new Matrix(r, b.c);
  for (int i = 0; i < b.c; i++)
    for (int j = 0; j < r; j++)
      for (int k = 0; k < c; k++)
        result->matrix[i][j] += matrix[i][k] * b.matrix[k][j];
  return result;
}
 

In matrix[i][k] i and k have the wrong range for matrix, k 0 to c-1 may be ok but i 0 to b.c-1 does not necessarily have the same range as 0 to r-1.

[ratherthanwords]

Thanks Banfra...I'll have to try that.

What baffles me about the problem is that it compiles and runs under linux...and produces proper output for larger matrices (i.e. 3x2 multiplied by a 2x3). It's the visual studio compiler that causes it to crash, and not even all the time....

For example, I just ran it now, and it did the multiplication and returned a correct result... Running a second time caused the debug assertion (on the same dataset)...

I'll try your fixes though and see if that helps.