2D数组的连续内存分配—释放内存

Question

I am facing a heap crash during free() when I run this program, but I am successful if I do debug using F10 (in Visual studio 2010).

My piece of code:

The below code is used to free. Can someone please explain deallocation for 2D array in this case?

void Deallocate2D ( SINT32  **pAccess, UINT8 i_ubyNoOfRows )
{
    int i;
    UINT8 *elem;
    if ( NULL == pAccess )
    {
        printf ( "%d>Invalid Params\n", __LINE__ ); 
        return;
    }

    printf ( "\nDeallocate 2D Array..................\n" );

    /* Include the code to deallocate the 2D array */
    {   
            free(pAccess);  

    }
}

The below code is used for memory allocation:

SINT32 Allocate2D ( 
                SINT32  ***pAccess, 
                UINT8   i_ubyNoOfRows, 
                UINT8   i_ubyNoOfCols )
{
    SINT32  nResult = -1;
    SINT32  **pAc = NULL;
    UINT8   *pubyPositioner;
    UINT32  unTotalSize;
    int i;

    //unTotalSize = i_ubyNoOfRows * i_ubyNoOfCols;
    printf ( "\nAllocate 2D Array..................\n" );

    /* Include the code to allocate the 2D array */
    {

    /*Contiguous memallocation  pAc*/
    pAc = (SINT32**)malloc(sizeof(SINT32*) * i_ubyNoOfRows);
    if(pAc)
        pubyPositioner = (UINT8*)malloc(sizeof(UINT8) * i_ubyNoOfCols);
    if(pubyPositioner)
        for(i = 0; i < i_ubyNoOfCols; ++i)
            pAc[i] = (SINT32*)pubyPositioner + (i * i_ubyNoOfCols);             

    *pAccess = pAc;

    /*Non contugious allocation*/
    /*  
        pAc = (SINT32**)malloc(sizeof(SINT32*) * i_ubyNoOfRows );
        *pAccess = pAc;
        if(pAc)
         for(i= 0; i < i_ubyNoOfRows; ++i){
            pAc[i] = (SINT32*)malloc(sizeof(SINT32*) + (i * i_ubyNoOfRows) );
            if(pAc[i])
                for(j = 0; j < i_ubyNoOfCols; ++j)
                    pAc[i][j] = (UINT8)malloc(sizeof(UINT8) +   (i_ubyNoOfRows * i_ubyNoOfCols) );

         }

     */
        if(*pAccess != NULL)
            nResult = 0;


    }

    if ( NULL == pAccess )
    {
        printf ( "%d>Invalid Params\n", __LINE__ ); 
        return -1;
    }

    return nResult;
}

The code to fill array and print array:

SINT32 Fill2D ( 
                SINT32  **pnAccess,
                SINT32  *pnData,
                UINT8   i_ubyNoOfRows, 
                UINT8   i_ubyNoOfCols )
{
    SINT16  wRIndex, wCIndex, wDataIndex = 0;   



    printf ( "\nFill 2D Array..................\n" );

    /* Include the code to fill the 2D array with the 1D values */
    {
        for(wRIndex = 0 ; wRIndex < 3; ++wRIndex)
            for(wCIndex = 0; wCIndex < 3; ++wCIndex)
                pnAccess [wRIndex][wCIndex] = pnData[wDataIndex++];

    }

    if ( ( NULL == pnAccess ) \
            || ( NULL == pnData ) )
    {
        printf ( "%d>Invalid Params\n", __LINE__ ); 
        return -1;
    }

    return 0;
}

SINT32 Print2D ( 
                SINT32  **pnAccess,
                UINT8   i_ubyNoOfRows, 
                UINT8   i_ubyNoOfCols )
{
    SINT16  wRIndex, wCIndex;

    if ( NULL == pnAccess )
    {
        printf ( "%d>Invalid Params\n", __LINE__ ); 
        return -1;
    }

    printf ( "\n2D Array..................\n\n" );

    /* Include the code to Print the 2D array in matrix format */
    {
        for(wRIndex = 0 ; wRIndex < i_ubyNoOfRows; ++wRIndex)
        {
            if(wRIndex % 2 == 0)
                printf("\n");
            for(wCIndex = 0; wCIndex < i_ubyNoOfCols; ++wCIndex)
                printf("%d ", pnAccess[wRIndex][wCIndex]); 

        }
    }

    return 0;
}

The below code is kind of entry point:

void Test2DArray ( void )
{
    SINT32  **pnData = NULL;
    SINT32  nData1[] = { 10, 15, 20, 15, 20, 25, 10, 25, 20 };
    SINT32  nData2[] = { 70, 75, 80, 65, 90, 25, 30, 35, 80 };

    printf ( "\n==================================\n" );
    printf ( "Test 2D Array..................\n" );
    printf ( "==================================\n\n" );

    if ( Allocate2D( &pnData, 3, 3 ) != -1 )
    {
        if ( Fill2D( pnData, nData1, 3, 3 ) != - 1 )
        {
            if ( NULL != pnData )
            {
                Print2D ( pnData, 3, 3 );
                Deallocate2D ( pnData, 3 );
            }
        }
    }

    if ( Allocate2D( &pnData, 3, 3 ) != -1 )
    {
        if ( Fill2D( pnData, nData2, 3, 3 ) != - 1 )
        {
            if ( NULL != pnData )
            {
                Print2D ( pnData, 3, 3 );
                Deallocate2D ( pnData, 3 );
            }
        }
    }
}

Answer 1

 /*Contiguous memallocation  pAc*/
    pAc = (SINT32**)malloc(sizeof(SINT32*) * i_ubyNoOfRows);
    if(pAc)
        pubyPositioner = (UINT8*)malloc(sizeof(UINT8) * i_ubyNoOfCols);
    if(pubyPositioner)
        for(i = 0; i < i_ubyNoOfCols; ++i)
            pAc[i] = (SINT32*)pubyPositioner + (i * i_ubyNoOfCols);   

This is not contiguous memory allocation! It is a pointer-based lookup table which is allocated in one segment, pointing at a chunk of memory allocated in another segment.

Correct code for allocating a true 2D array would be:

SINT32 (*pAc)[ubyNoOfCols] = malloc( sizeof(SINT32[i_ubyNoOfCols][i_ubyNoOfRows]) );
...
free(pAc);

Note that this will only compile on a C compiler, so you can't use Visual Studio.

---

Can someone please explain deallocation for 2D array in this case?

free(pAccess); 

Looks like the code only deallocates the pointer lookup table and not the actual data. So I suppose that is a bug: the code contains memory leaks.

Answer 2

Lets take a look at your allocation code:

pAc = (SINT32**)malloc(sizeof(SINT32*) * i_ubyNoOfRows);
if(pAc)
    pubyPositioner = (UINT8*)malloc(sizeof(UINT8) * i_ubyNoOfCols);
if(pubyPositioner)
    for(i = 0; i < i_ubyNoOfCols; ++i)
        pAc[i] = (SINT32*)pubyPositioner + (i * i_ubyNoOfCols);             

So, you are first allocating memory for i_ubyNoOfRows pointers. This is fine.
Then you proceed to allocate i_ubyNoOfCols bytes , (3 bytes in your test case), but you need space for i_ubyNoOfCols*i_ubyNoOfRows integers (3*3*4 = 36 bytes in your test case, assuming int is a 32-bit type).
When you proceed to initialize your memory, you trod on data vital for malloc() and free() to function properly.

A telltale sign of one half of your mistake is the cast in the line pAc[i] = (SINT32*)pubyPositioner + (i * i_ubyNoOfCols); . It shows that you used a wrong type for pubyPostitioner .

Ps: You have two 3 s hardcoded in Fill2D() , even though this function gets the correct width and height passed as arguments.

Answer 3

In my question,I wanted to allocate memory for 2D array then free it. After some study, i have explained my understanding as below

1. Allocate memory using array of pointers

double **p;
int i;
p= malloc(rows * sizeof(*p));
for(i= 0; i<rows;++i)
p[i] = malloc(cols * sizeof(double));

... ...

for(i=0;i<rows;i++)
    free(p[i]);
 free(p);

1. allocation using pointer lookup table

double **p;
double *elem;

elem = malloc(rows * cols * sizeof(double));
p = malloc(cols * sizeof(double*));
for (i = 0; i<rows;++i)
p[i] =  elem + ( i*cols);

free(p);

1. Contiguous Allocation

double **p;
p = malloc( rows * cols * sizeof(double*));
/*Accessing / printing values ... assume values are assinged to this array*/
for(i=0; i <rows; ++i)
 for(j = 0; j< cols; ++j)
  printf("%d",p[j + (i * cols)]);

free(p)