Thread: Dynamic arrays initialization

I want to create arrays within structures whose sizes I do not know untill I finish the loop.
I thought I needed to reallocate the size after every loop iteration is done so that it would have enough memory for the next iteration,
but then I get an error, whereas it seems to be okay when I do not reallocate size.

Can you please tell me if I need to reallocate memory here after every loop iteration?
And what is generally the rule to do with initializing arrays whose size and members we don't know in advance?

Code:

for(co_b=0;  co_b < aaa->no_b; co_b++) {

     int i=0;

     if ((aaa->bbb[co_b].ce = (double *)malloc(sizeof(double)*2)) == NULL) {
        fprintf(stdout, "/nOut of Memory");
        return EXIT_FAILURE;
    }

    for(co_x=0; co_x < aaa->bbb[co_b].no_x;  co_x++) {

    aaa->bbb[co_b].ce[i]=5*x;
    aaa->bbb[co_b].ce[i+1]=10*x;

    i=i+2;

// if I add this part below I get an error saying:
// size realloc(): invalid next size:
// and then later core dumped


    if ((aaa->bbb[co_b].ce = (double *)realloc(aaa->bbb[co_b].ce, sizeof(double) * (i+1)) ) == NULL) {
        fprintf(stdout, "\nOut of Memory!");
        exit (EXIT_FAILURE);
    }



  }

}

You need to indent your code properly, e.g.,

Code:

int i=0;

for (co_b=0; co_b < aaa->no_b; co_b++) {

    for (co_x=0; co_x < aaa->bbb[co_b].no_x; co_x++) {

        if ((aaa->bbb[co_b].ce = (double *)malloc(sizeof(double)*2)) == NULL) {
            fprintf(stdout, "/nOut of Memory");
            return EXIT_FAILURE;
        }

        aaa->bbb[co_b].ce[i]=5*x;
        aaa->bbb[co_b].ce[i+1]=10*x;

        i=i+2;

        // if I add this part below I get an error saying:
        // size realloc(): invalid next size:
        // and then later core dumped

        if ((aaa->bbb[co_b].ce = (double *)realloc(aaa->bbb[co_b].ce, sizeof(double) * (i+1)) ) == NULL) {
            fprintf(stdout, "\nOut of Memory!");
            exit (EXIT_FAILURE);
        }

    }

}

The problem appears to be that you are always allocating space for aaa->bbb[co_b].ce within the inner loop using malloc. Hence, your realloc is pointless: you will overwrite it on subsequent iterations. What you probably should do is something like this:

Code:

int i=0;

for (co_b=0; co_b < aaa->no_b; co_b++) {

    if ((aaa->bbb[co_b].ce = (double *)malloc(sizeof(double)*2)) == NULL) {
        fprintf(stdout, "/nOut of Memory");
        return EXIT_FAILURE;
    }

    for (co_x=0; co_x < aaa->bbb[co_b].no_x; co_x++) {

        aaa->bbb[co_b].ce[i]=5*x;
        aaa->bbb[co_b].ce[i+1]=10*x;

        i=i+2;

        // if I add this part below I get an error saying:
        // size realloc(): invalid next size:
        // and then later core dumped

        if ((aaa->bbb[co_b].ce = (double *)realloc(aaa->bbb[co_b].ce, sizeof(double) * (i+1)) ) == NULL) {
            fprintf(stdout, "\nOut of Memory!");
            exit (EXIT_FAILURE);
        }

    }

}

Hi, sorry that was my mistake while simplifying the code and copying it here, thanks, malloc was actually originally in the outer loop, not the inner so that wasn't the problem. I edited the question now.

It's best not to use an initial malloc when you are reallocing for every new record. Instead, start the pointer at NULL and call realloc when you know you need the extra space.

Code:

for(co_b=0;  co_b < aaa->no_b; co_b++) {
 
    int i=0;
    aaa->bbb[co_b].ce = NULL;

    for(co_x=0; co_x < aaa->bbb[co_b].no_x;  co_x++) {
 
        if ((aaa->bbb[co_b].ce = realloc(aaa->bbb[co_b].ce, sizeof(double) * (i+2)) ) == NULL) {
            perror("realloc");
            exit (EXIT_FAILURE);
        }
 
        aaa->bbb[co_b].ce[i] = 5 * x;
        aaa->bbb[co_b].ce[i+1] = 10 * x;

        i += 2;

Originally Posted by Layla_E

Do you know perhaps why it seemed as if it works fine even without memory reallocation, i.e. the code as it is in my question with malloc, but without realloc?

I don't know in detail what's going on but the basic idea is that there is usually more memory assigned to your process by the OS than you have actually requested from the allocator (malloc/calloc/realloc).

Presumably the realloc calls cause the allocator to notice the problem by recognizing that it's housekeeping data has been overwritten.