在for循环的每次迭代中动态分配memory以制作动态数组

Question

what's the problem with this code? i am trying to allocate 1 int size memory every time for loops run, but this code doesn't print anything

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int *a;
    for(int i=0;i<5;i++)
    {
        a=(int *)malloc(1*sizeof(int));
        a[i]=i;
    }
    for(int i=0;i<5;i++)
    {
        printf("%d\n",a[i]);
    }
    free(a);

}

Answer 1

What you need to do is allocate memory for each integer separately, but you are not doing it.

You are doing repeated allocation for same variable a , which is not the right way to do and also causes the memory leak because you are loosing the previous pointer values

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *a[5] = {NULL};

    for(int i = 0; i < 5;i++)
    {
        a[i] = malloc(sizeof(int));
        if(a[i])
            *a[i] = i;
        else
            puts("cannot malloc");
    }
    
    for(int i = 0; i < 5; i++)
    {
        printf("addr = %p and value = %d\n",a[i],*a[i] );
        free(a[i]);
        a[i] = NULL;
    }
    return 0;
}

But if you just want to store 5 integers then the above method is a superfluous way, instead allocate memory for 5 integers at a time and use it as shown below.

a = malloc(5 * sizeof(int));
for(int i = 0;i < 5; i++)
    a[i] = i;

and once you are done with it, you can say free(a); a = NULL; free(a); a = NULL;

Answer 2

if you wanna allocate 1-D array do this

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int *a = (int*)malloc(5*sizeof(int)); // allocate 5 int-items on your array 'a'
    for(int i=0;i<5;i++)
    {
        a[i]=i;
    }
    for(int i=0;i<5;i++)
    {
        printf("%d\n",a[i]);
    }
    free(a);
}

you don't need to allocate each a[i] separately.

And, i assume that you will be get some hard to make 2-D array.

if you want do that. try this

#include<stdio.h>
#include<stdlib.h>
int main()
{ // make 5 * 5 array
    int **a = (int**)malloc(5*sizeof(int*));
    for(int i=0;i<5;i++)
    {
        a[i] = (int*)malloc(5*sizeof(int));
    }

    ... do some logics

    for(int i = 0; i < 5; i++) {
        free(a[i]); // you need to free each a[i] to prevent memory leak.
    }
    free(a); // finally, free a (int**)
}

Answer 3

If you already know the number of objects to allocate, you are not really dynamically resizing anything, you are simply allocating a block of memory to hold that number of objects.

The distinction when allocating storage for objects instead of just creating an array is the storage duration for the collection of objects. Declaring a plain old array results in the array having automatic storage duration (valid lifetime of array is limited to the scope where it was declared). A block of memory allocated with malloc , calloc or realloc has allocated storage duration (valid until freed or program exit) C11 Standard - 6.2.4 Storage durations of objects

When you allocate memory with malloc , calloc or realloc , the function reserves the number of bytes requested and returns the beginning address to the block of memory allocated on success, NULL on failure.

You have 2 responsibilities regarding the block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed. In your code you fail to do (1). When you place the allocation within your loop, eg

    a=(int *)malloc(1*sizeof(int));

You overwrite the address held by a as its value -- on each iteration. By not preserving a pointer to each block of memory, you create a memory-leak each time you overwrite the address held by a , because the address to the previous block of memory is lost and you cannot free() the block of memory failing (2) above.

( note: in C, there is no need to cast the return of malloc , it is unnecessary. See: Do I cast the result of malloc? )

To fix your immediate problem, simply allocate before entering the loop, eg:

#include <stdio.h>
#include <stdlib.h>

#define NOBJ 5          /* if you need a constant, #define one or more */

int main (void) {
    
    int *a = malloc (NOBJ * sizeof *a);             /* allocate storage for n objects */
    
    if (a == NULL) {                                /* validate EVERY allocation */
        perror ("malloc-a");
        return 1;
    }
    
    for (int i = 0; i < NOBJ; i++)                  /* fill a */
        a[i] = i;
        
    for (int i = 0; i < NOBJ; i++)                  /* output a */
        printf ("a[%d]: %d\n", i, a[i]);

    free (a);                                       /* free allocated memory */
}

Example Use/Output

$ ./bin/malloc-a
a[0]: 0
a[1]: 1
a[2]: 2
a[3]: 3
a[4]: 4

Memory Use/Error Check

It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.

For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.

$ valgrind ./bin/malloc-a
==5019== Memcheck, a memory error detector
==5019== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==5019== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==5019== Command: ./bin/malloc-a
==5019==
a[0]: 0
a[1]: 1
a[2]: 2
a[3]: 3
a[4]: 4
==5019==
==5019== HEAP SUMMARY:
==5019==     in use at exit: 0 bytes in 0 blocks
==5019==   total heap usage: 2 allocs, 2 frees, 1,044 bytes allocated
==5019==
==5019== All heap blocks were freed -- no leaks are possible
==5019==
==5019== For counts of detected and suppressed errors, rerun with: -v
==5019== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Always confirm that you have freed all memory you have allocated and that there are no memory errors.

Dynamically Sizing Storage

When you have an unknown number of objects to store, then you must dynamically allocate storage. The approach is straight forward. You initially allocate for some reasonably anticipated number of objects and keep two counters, one for the number of objects that can fit in the allocated memory currently available , and a second counter for the number of those allocated objects you have used . When used == available* you must realloc` to resize your block of memory create more available storage space. Repeat until you have run out of objects to store.

When you call realloc() you always realloc() using a temporary pointer so if realloc() fails returning NULL , you don't overwrite the address to the currently allocated block with NULL creating a memory-leak. For example never do:

        if (used == avail) {                        /* is reallocation needed? */
            a = realloc (a, 2 * avail * sizeof *a);

Instead do:

        if (used == avail) {                        /* is reallocation needed? */
            /* always realloc to a temporary pointer */
            void *tmp = realloc (a, 2 * avail * sizeof *a);
            if (!tmp) {                             /* validate EVERY reallocation */
                perror ("realloc-a");
                break;
            }
            a = tmp;                                /* assigned resized block to a */
            ...

That way when , (not if ), realloc() fails, you preserve a pointer to your original block of memory in a . It still points to the valid data stored in a immediately prior to the call to realloc() .

Below is a short example that initially allocates for 2 integer values and then generates a random number between 10 and 50 and fills that number of objects, reallocating storage as needed. For an additional bit of unknown, if the original number of random objects was odd , then another random number of values between 10 and 50 is added to the original number and filling and reallocation continues until all values are stored, eg

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define AVAIL  2        /* if you need a constant, #define one or more */
#define OMAX  50        /* maximum no. of objects per-random increment */
#define OMIN  10        /* minimum no. of objects per-random increment */

int main (void) {
    
    size_t  used = 0,                               /* number of objects used */
            avail = AVAIL,                          /* number available */
            nrealloc = 0,                           /* number of reallocations */
            nobjects;                               /* random no. of objects to fill */
    int *a = malloc (avail * sizeof *a);            /* allocate storage for n objects */
    
    if (a == NULL) {                                /* validate EVERY allocation */
        perror ("malloc-a");
        return 1;
    }
    
    srand (time(NULL));                             /* seed random no. generator */
    nobjects = rand() % (OMAX - OMIN + 1) + OMIN;   /* random no 10 - 50 */
    
    while (used < nobjects) {                       /* loop until a contains nobjects */
        if (used == avail) {                        /* is reallocation needed? */
            /* always realloc to a temporary pointer */
            void *tmp = realloc (a, 2 * avail * sizeof *a);
            if (!tmp) {                             /* validate EVERY reallocation */
                perror ("realloc-a");
                break;
            }
            a = tmp;                                /* assigned resized block to a */
            avail *= 2;                             /* update available objects */
            nrealloc += 1;                          /* add to no. of reallocations */
        }
        a[used] = used;                             /* assign value */
        used++;                                     /* increment used count */
    }
    
    if (used & 1) {     /* if odd number used, add to nobjects */
        size_t group1 = nobjects;
        nobjects += rand() % (OMAX - OMIN + 1) + OMIN;
        printf ("\nnobjects increased from %zu - %zu\n\n", group1, nobjects);
    }
    
    while (used < nobjects) {                       /* loop until a contains nobjects */
        if (used == avail) {                        /* is reallocation needed? */
            /* always realloc to a temporary pointer */
            void *tmp = realloc (a, 2 * avail * sizeof *a);
            if (!tmp) {                             /* validate EVERY reallocation */
                perror ("realloc-a");
                break;
            }
            a = tmp;                                /* assigned resized block to a */
            avail *= 2;                             /* update available objects */
            nrealloc += 1;                          /* add to no. of reallocations */
        }
        a[used] = used;                             /* assign value */
        used++;                                     /* increment used count */
    }
    
    /* results */
    printf ("allocations   : 1\nreallocations : %zu\n\n", nrealloc);
    for (size_t i = 0; i < used; i++)               /* output a */
        printf ("a[%3zu]: %d\n", i, a[i]);

    free (a);                                       /* free allocated memory */
}

Example Use/Output

( note: the original number of objects was 19 (odd) so the second random block of objects was allocated for and added to a )

$ ./bin/malloc-realloc-a

nobjects increased from 19 - 44

allocations   : 1
reallocations : 5

a[  0]: 0
a[  1]: 1
a[  2]: 2
a[  3]: 3
a[  4]: 4
a[  5]: 5
a[  6]: 6
a[  7]: 7
a[  8]: 8
a[  9]: 9
a[ 10]: 10
...
a[ 40]: 40
a[ 41]: 41
a[ 42]: 42
a[ 43]: 43

You can choose any number or factor of additional objects to allocate for when you realloc() , but doubling the current size is convenient and balances growing the storage against the number of times realloc() is needed reasonably well. For example, you can grow from 2 initially allocated object to more than 2,000,000 in 20 reallocations. You can also call realloc() a final time with the total number used to shrink the total allocation to the exact size needed.

Look things over and let me know if you have further questions.