How to use malloc/free for a 2D pointer in the for loop?

Question

0.00/5 (No votes)

See more:

Hi,

I have a 2D array definded by pointer like ** ptr.

I need to use malloc to allocate memory to it (**ptr). **ptr is used inside a for loop. When should I need to use malloc/free for this **ptr, inside for loop or outside for loop? Why?

Thanks very much in advanced.

Posted 27-Oct-12 15:06pm

DawnLee

Add a Solution

5 solutions

Solution 1

You can free allocated memory based on the operations you are doing on the allocated memory, if the operation finishes inside the loop then go ahead and free it. If you are concerned with variable length of allocation, try to define null buffer outside the loop and use realloc inside the loop with specific length. Then you can free it outside the loop(as the case may be). Eg:-

C

char * buffer = NULL;
for (int i = 0; i < 100; i++) {
    buffer = realloc(specific_length_int);
    // do some things with buffer
}
free(buffer);

Posted 27-Oct-12 16:54pm

Kuthuparakkal

Updated 27-Oct-12 16:55pm

v2

Solution 2

When? Only you can answer that question, as only you know the requirements of the program. You allocate memory when and where you need to use it, and you free it when you no longer need it. Sometimes you will need to do that inside a loop and sometimes outside. Without a lot more detail of your problem it is impossible to be more precise.

Posted 28-Oct-12 0:52am

Richard MacCutchan

Comments

DawnLee 28-Oct-12 11:16am

Thank you.

My codes roughly like those:

int **ptr;

int a = 0;

do {

for (int i=0; i<100; i++){
for (int j = 0; j<80; j++){
ptr[i][j] = a ;
}
}
a++;
}while(a<64 );

Inside do/while loop, **ptr will be used 64 times in the for loop. So, in this situation, where should I use malloc/free for **ptr?
Thanks in advanced.

Solution 3

The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized. If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be successfully passed to free().
So you just do it like this:

C++

char** ptr=(char**)malloc(100);
free(ptr);

Don't think inside loop or outside loop, It's just a address of memory!

Posted 28-Oct-12 1:58am

sum_and_sum

Solution 4

Your comments suggest a 3D array rather than a 2D. So if we remove the do {} while (a < 64); block we could fill a 100 x 80 element 2D array thus:

C++

int rows = 100;		// number of rows in each plane
int cols = 80;		// number of columns in each row

// ptr will point to the first element of the array(s)
int **ptr;
// allocate pointers to the rows
ptr = (int**)calloc(rows, sizeof(int*));
// initialise the element content value
int a = 0;

// start iterating the rows in each plane
for (int i=0; i<rows;>{
    // allocate an array of integers for the elements of each column
    ptr[i] = (int*)calloc(cols, sizeof(int));
    // for each column ...
    for (int j = 0; j<cols;>    {
        // set the value of each element in the column to the value of the element counter
        ptr[i][j] = a++;
        // display the indices and value of each element.
        cout << "ptr[" << i << "][" << j << "] = " << a << endl;
        }
}

Note that I used the calloc() function as it makes more sense when allocating anything other than an array of bytes.

The arrays can be freed when the program no longer needs them, and would be in the reverse order of the malloc() calls; I leave that as an exercise for you.

Posted 28-Oct-12 6:22am

Richard MacCutchan

Comments

DawnLee 28-Oct-12 12:54pm

Thank you. However, I do need to use do/while loop for the **ptr to be iteratly used in a function. Based on your codes, which way is more reasonable for allocating memory for **ptr and why?

Way 1:

int rows = 100; // number of rows in each plane
int cols = 80; // number of columns in each row

// ptr will point to the first element of the array(s)
int **ptr;
// allocate pointers to the rows
ptr = (int**)calloc(rows, sizeof(int*));
// initialise the element content value
int a = 0;

do{

// start iterating the rows in each plane
for (int i=0; i<rows;>{
// allocate an array of integers for the elements of each column
ptr[i] = (int*)calloc(cols, sizeof(int));
// for each column ...
for (int j = 0; j<cols;> {
// set the value of each element in the column to the value of the element counter
ptr[i][j] = a++;
// display the indices and value of each element.
cout << "ptr[" << i << "][" << j << "] = " << a << endl;
}
}

input(ptr, writ); // just a example of a function read in and write out
output(writ);
}while (a<64);
free(ptr);

Way 2:

int rows = 100; // number of rows in each plane
int cols = 80; // number of columns in each row

// ptr will point to the first element of the array(s)
int **ptr;
// allocate pointers to the rows
// initialise the element content value
int a = 0;

do{

ptr = (int**)calloc(rows, sizeof(int*));

// start iterating the rows in each plane
for (int i=0; i<rows;>{
// allocate an array of integers for the elements of each column
ptr[i] = (int*)calloc(cols, sizeof(int));
// for each column ...
for (int j = 0; j<cols;> {
// set the value of each element in the column to the value of the element counter
ptr[i][j] = a++;
// display the indices and value of each element.
cout << "ptr[" << i << "][" << j << "] = " << a << endl;
}
}

input(ptr, writ); // just a example of a function read in and write out
output(writ);

free(ptr);

}while (a<64);

By Way 1, I allocate memory size to the ptr once outside do/while loop. The ptr will be used repeatedly for 64 times. Then the ptr will be free once outside do/while loop.

By using Way 2, I allocate memory size to ptr and free it at each do/while loop.

So, which way is reasonable to a pointer to be allocated memory.

Thank you very much.

Richard MacCutchan 28-Oct-12 14:00pm

See my latest suggestion

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard MacCutchan · Accepted Answer · 2012-10-28T08:00:00

I think you may be looking for something more like the following. You need to allocate your arrays outside the do {} while(a < 64); loop, otherwise you will be allocating duplicate entries and leaking memory. Then within that loop you set the values in the array and pass it to your other functions. When that loop completes you need to free() the array in each row and finally the array of pointers to the rows.

C++

int rows = 100;		// number of rows in the array
int cols = 80;		// number of columns in each row

// ptr will point to the first element of the array(s)
int **ptr;
// allocate rows, pointers to the columns
ptr = (int**)calloc(rows, sizeof(int*));
for (int i=0; i<rows;>{
    // allocate an array of columns for each row
    ptr[i] = (int*)calloc(cols, sizeof(int));
}
// initialise the loop count
int a = 0;
// start the iteration
do
{
    // for each row ...
    for (int i=0; i<rows;>    {
        // and each column in the row ...
        for (int j = 0; j<cols;>        {
            // set the value of each element in the column to the variable
            ptr[i][j] = a;
            // display the indices and value of each element.
            cout << "ptr[" << i << "][" << j << "] = " << a << endl;
        }
    }
    // when all elements are initialised
    input(ptr, writ);  // just a example of a function read in and write out
    output(writ);
    a++;	// increment to the next iteration
} while(a < 64);

// release the allocated memory
for (int i=0; i<rows;>{
    // free the element array in each row
    free(ptr[i]);
}
// free the array of row pointers
free(ptr);