Exception assembly code error with a matrix to array function conversion call in main function

Question

I'd like to convert a Matrix into an array, which I managed to do inside the main function, but when time to come to put it in a function, it stops working and I get an access violation error which didn't show inside the main scope.

Here is the code, I need help to complete the conversion. I need to cast it from a class function for my project.

#include <iostream>

const int rows = 3, cols = 4; //define constant rows and columns

int* MatrixToArray(static int* matrix[rows][cols]) {
    int* array[rows*cols]{};//initialize the array
    int* ptrResult=nullptr;//initialize the return variable

    //First loop to fill the matrix with dissociated values to print out
    for (int i = 0; i < rows-1; i++) {
        for (int j = 0; j < cols-1; j++) {
            if (matrix) {
                *matrix[i][j] = i + j + i * (j + cols); ///exception violation access memory 
            }
            if (matrix) {//debug warning C6011
                std::cout << " [" << *matrix[i][j] << "]";
            }
            
        }
        std::cout << ",\n";
    }
    
    //second reversed loop to get the unified array from the previous matrix
            for (int u = 0; u < 1; u++) {
                for (int i = 0; i < rows; i++) {
                    for (int j = 0; j < cols; j++) {
                        if (array) {//debug warning C6011
                            array[u] = matrix[i][j];
                            if (ptrResult) {//debug warning C6011
                                ptrResult = array[u];
                            }
                        }
                        std::cout << "[" << *array[u] << "] ";
                    }
            }
        }
        free(array);
    
    return ptrResult;
}

int main()
{
    int* matrix[rows][cols];
    std::cout << MatrixToArray(matrix);
}

After adapting the types for the matrix and the array, I get this code :

#include <iostream>

const int rows = 3, cols = 4; //define constant rows and columns

int* MatrixToArray(int** matrix) {
    int* array[rows*cols]{};//initialize the array
    int* ptrResult=nullptr;//initialize the return variable
//allocate memory as requested in the subedit comment field answers
    matrix = new int* [rows];
    for (int i = 0; i < rows; ++i)
        matrix[i] = new int[cols];

    //First loop to fill the matrix with dissociated values to print out
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix) {
                matrix[i][j] = i + j + i * (j + cols); ///exception violation access memory disappear
            }
            if (matrix) {//debug warning C6011
                std::cout << " [" << matrix[i][j] << "]";
            }
            
        }
        std::cout << ",\n";
    }
    
    //second reversed loop to get the unified array from the previous matrix
    if (array) {
            for (int u = 0; u < 1; u++) {
                for (int i = 0; i < rows; i++) {
                    for (int j = 0; j < cols; j++) {
                        if (array) {//debug warning C6011
                            array[u] = &matrix[i][j];
                            if (ptrResult) {//debug warning C6011
                                ptrResult = array[u];
                            }
                        }
                        //std::cout << "[" << *array[u] << "] ";
                    }

            }
        }
        free(array);//File: minkernel crts ucrt src appcrt heap debug_heap.cpp Line:904 expression: _CrtlsValidHeapPointer(block)
    }
    
    return ptrResult;
}

int main()
{
//memory allocation correction
    int** matrix;
    matrix = new int* [rows];
    for (int i = 0; i < rows; ++i)
        matrix[i] = new int[cols];
    std::cout << MatrixToArray(matrix);
}

I still get an exception error, but in the assembly code which ends up into the message copied in the comment next to the line quoted.

Answer 1

#include <iostream>

const int rows = 3, cols = 4; //define constant rows and columns

int* MatrixToArray(int** matrix) {
    int* array= new int[rows * cols]{};//initialize the array (with new keyword)
    int* ptrResult=nullptr;//initialize the return variable

    matrix = new int* [rows];
    for (int i = 0; i < rows; ++i)
        matrix[i] = new int[cols];
    std::cout << "[";
    //First loop to fill the matrix with dissociated values to print out
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix) {
                matrix[i][j] = i + j + i * (j + cols); ///exception violation access memory disappeared 
            }
            if (matrix) {//debug warning C6011
                std::cout << " [" << matrix[i][j] << "]";
            }
        }
        if (i != rows - 1) {
            std::cout << ",\n";
        }

    }std::cout << "]";
    
    //second reversed loop to get the unified array from the previous matrix
                for (int i = 0; i < rows; i++) {
                    for (int j = 0; j < cols; j++) {
                        if (array) {//debug warning C6011
                            array[0] = matrix[i][j]; //modified with new initialization
                            if (ptrResult) {//debug warning C6011
                                *ptrResult = array[0];//modified with new initilization
                            }
                        }
            }
        }
    delete[] array;
    return ptrResult;
}

int main()
{
    int** TheMatrix;
    TheMatrix = new int* [rows];
    for (int i = 0; i < rows; ++i)
        TheMatrix[i] = new int[cols];
    std::cout << MatrixToArray(TheMatrix);

    for (int i = 0; i < rows; ++i) {
        delete[] TheMatrix[i];
    }
    delete[] TheMatrix;
}

Finally, I tweaked the pointers, and I got rid of the exception in the assembly mode, But I get a serie of zeros popping out in the end...

Answer 2

I'd like to convert a Matrix into an array

Given what you have stated in your question, there is no need to turn a two-dimensional array into a one-dimensional array, if the two-dimensional array is either:

1. A "traditional" C++ array (i.e. int matrix[10][10];) or
2. A two-dimensional array built from a T** in a contiguous manner.

Both the items above have the same property, and that is the data is in contiguous memory, no different than a single dimension array. Thus a 2-dimensional array is already a 1 dimensional array.

The only difference between item 1 and item 2 above in terms of contiguousness is that item 1 is "pre-built", while item 2 requires you to build the two-dimensional array.

For item 2). the answer here shows a complete class that builds the matrix from any T** in a contiguous manner. The way you're building the 2-dimensional array does not create the data in contiguous memory, since each row is allocated separately.

Once you have the matrix, the way you use it in a one-dimensional fashion is to pass the address of the items to whatever function or entity requires a pointer to a one-dimensional array.

Here is an example (for the int**, we will use the code in the other linked answer).

#include <iostream>
#include <exception>
#include <numeric>

template <typename T>
T** create2DArray(unsigned nrows, unsigned ncols, const T& val = T())
{
   if (nrows == 0)
        throw std::invalid_argument("number of rows is 0");
   if (ncols == 0)
        throw std::invalid_argument("number of columns is 0");
   T** ptr = nullptr;
   T* pool = nullptr;
   try
   {
       ptr = new T*[nrows];  // allocate pointers (can throw here)
       pool = new T[nrows*ncols]{val};  // allocate pool (can throw here)

       // now point the row pointers to the appropriate positions in
       // the memory pool
       for (unsigned i = 0; i < nrows; ++i, pool += ncols )
           ptr[i] = pool;

       // Done.
       return ptr;
   }
   catch (std::bad_alloc& ex)
   {
       delete [] ptr; // either this is nullptr or it was allocated
       throw ex;  // memory allocation error
   }
}

template <typename T>
void delete2DArray(T** arr)
{
   delete [] arr[0];  // remove the pool
   delete [] arr;     // remove the pointers
}

// The MatrixToArray function takes a pointer to a buffer and prints the info
void MatrixToArray(int data[], int numItems)
{
   for (int i = 0; i < numItems; ++i)
     std::cout << data[i] << " ";
   std::cout << "\n";
}

int main()
{
    int test1[] = {1,2,3,4,5,6,7,8,9,10};  // a 1-dimensioanl array
    int test2[2][5] = {{1,2,3,4,5},{6,7,8,9,10}}; // a 2-dimensional array

    int **test3 = create2DArray<int>(2,5); // a dynamically created 2-d array
    // quickly fill the above with the same data as the other arrays
    std::iota(&test3[0][0], &test3[1][5], 1);

    // Now test each one to prove that the same MatrixToArray function works for 
    // 1-dimensional and 2-dimensional arrays.
    std::cout << "Output 1:\n";
    MatrixToArray(test1, 10);

    std::cout << "\nOutput 2:\n";
    MatrixToArray(&test2[0][0], 10);

    std::cout << "\nOutput 3:\n";
    MatrixToArray(&test3[0][0], 10);
    
    delete2DArray(test3);
}

Output:

Output 1:
1 2 3 4 5 6 7 8 9 10 

Output 2:
1 2 3 4 5 6 7 8 9 10 

Output 3:
1 2 3 4 5 6 7 8 9 10   

The same output is produced from the MatrixToArray function, regardless if the array is one-dimensional, or if the array is 2-dimensional traditional, or 2-dimensional array built dynamically.