Найти произведение матриц A и B - C (СИ)

#include <stdio.h>
#include <stdlib.h>
 
typedef struct TMatrix
{
  int* array;
 
  size_t rowCount;
  size_t colCount;
}* MATRIX_HANDLE;
 
enum
{
  no_error,
  error_invalid_handle,
  error_invalid_argument,
  error_mem_alloc,
  error_index_out_of_bounds
};
 
int CreateMatrix(MATRIX_HANDLE* hMatrixPtr, const size_t M, const size_t N)
{
  int errorCode = no_error;
 
  if ((hMatrixPtr == NULL) || (M == 0) || (N == 0))
  {
    errorCode = error_invalid_argument;
  }
  else
  {
    *hMatrixPtr = malloc(sizeof(**hMatrixPtr));
 
    if (*hMatrixPtr != NULL)
    {
      (*hMatrixPtr)->array = malloc(M * N * sizeof(*(*hMatrixPtr)->array));
 
      if ((*hMatrixPtr)->array != NULL)
      {
        (*hMatrixPtr)->rowCount = M;
        (*hMatrixPtr)->colCount = N;
      }
      else
      {
        errorCode = error_mem_alloc;
 
        free(*hMatrixPtr);
        *hMatrixPtr = NULL;
      }
    }
    else
    {
      errorCode = error_mem_alloc;
    }
  }
 
  return errorCode;
}
 
void DeleteMatrix(MATRIX_HANDLE* hMatrixPtr)
{
  if (hMatrixPtr != NULL)
  {
    free((*hMatrixPtr)->array);
    free(*hMatrixPtr);
  }
}
 
int SetValue(MATRIX_HANDLE hMatrix, const size_t i, const size_t j, const int value)
{
  int errorCode = no_error;
 
  if (hMatrix == NULL)
  {
    errorCode = error_invalid_handle;
  }
  else
  {
    if ((i > hMatrix->rowCount - 1) || (j > hMatrix->colCount - 1))
    {
      errorCode = error_index_out_of_bounds;
    }
    else
    {
      hMatrix->array[i * hMatrix->colCount + j] = value;
    }
  }
 
  return errorCode;
}
 
int GetValue(MATRIX_HANDLE hMatrix, const size_t i, const size_t j, int* valuePtr)
{
  int errorCode = no_error;
 
  if (hMatrix == NULL)
  {
    errorCode = error_invalid_handle;
  }
  else if (valuePtr == NULL)
  {
    errorCode = error_invalid_argument;
  }
  else
  {
    if ((i > hMatrix->rowCount - 1) || (j > hMatrix->colCount - 1))
    {
      errorCode = error_index_out_of_bounds;
    }
    else
    {
       *valuePtr = hMatrix->array[i * hMatrix->colCount + j];
    }
  }
 
  return errorCode;
}
 
int Multiply(MATRIX_HANDLE A, MATRIX_HANDLE B, MATRIX_HANDLE* hResultMatrixPtr)
{
  int errorCode = no_error;
  int a, b, sum;
 
  size_t i, j, k;
 
  if ((A == NULL) || (B == NULL))
  {
    errorCode = error_invalid_handle;
  }
  else if ((hResultMatrixPtr == NULL) || (A->colCount != B->rowCount))
  {
    errorCode = error_invalid_argument;
  }
  else
  {
    errorCode = CreateMatrix(hResultMatrixPtr, A->rowCount, B->colCount);
 
    if (errorCode == no_error)
    {
      for (i = 0; i < (*hResultMatrixPtr)->rowCount; i++)
      {
        for (j = 0; j < (*hResultMatrixPtr)->colCount; j++)
        {
          sum = 0;
          for (k = 0; k < A->colCount; k++)
          {
            GetValue(A, i, k, &a);
            GetValue(B, k, j, &b);
 
            sum = sum + a * b;
          }
 
          SetValue(*hResultMatrixPtr, i, j, sum);
        }
      }
    }
  }
 
  return errorCode;
}
 
void PrintMatrix(MATRIX_HANDLE hMatrix, const char* name)
{
  size_t i, j;
 
  int value;
 
  printf("------ Matrix '%s' ------\n", name);
  for (i = 0; i < hMatrix->rowCount; i++)
  {
    for (j = 0; j < hMatrix->colCount; j++)
    {
      GetValue(hMatrix, i, j, &value);
 
      if (j == hMatrix->colCount - 1) printf("%3d\n", value);
      else printf("%3d ", value);
    }
  }
  printf("-------------------------\n\n", name);
}
 
int main(void)
{
  MATRIX_HANDLE a, b, c;
 
  CreateMatrix(&a, 2, 3);
  CreateMatrix(&b, 3, 2);
 
  SetValue(a, 0, 0, 0);
  SetValue(a, 0, 1, 1);
  SetValue(a, 0, 2, 2);
  SetValue(a, 1, 0, 0);
  SetValue(a, 1, 1, 1);
  SetValue(a, 1, 2, 1);
 
  SetValue(b, 0, 0, 0);
  SetValue(b, 0, 1, 1);
  SetValue(b, 1, 0, 2);
  SetValue(b, 1, 1, 0);
  SetValue(b, 2, 0, 1);
  SetValue(b, 2, 1, 1);
 
  PrintMatrix(a, "A");
  PrintMatrix(b, "B");
 
  Multiply(a, b, &c);
 
  PrintMatrix(c, "C");
 
  DeleteMatrix(&a);
  DeleteMatrix(&b);
  DeleteMatrix(&c);
 
  return 0;
}