CODEWITHSUNDEEP
carraysmalloc
BillyJean
BillyJean

Reputation: 1577

professional array-handling

I am an unexperienced C-programmer: I want all the numbers below 5000 that are multiples of 5. Here is how I do this currently:

int main()
{
    int i;
    const int max =5000-1;
    for(i=2; i<(max+1); i++)
    {
        if(!(i%5))
        {
            printf("%d\n", i);
        }
    }
    return 0;
}

Say that I want them all listed in an array. What I could do is just to pre-allocate an integer array and fill out the various position. Naturally I can't know the exact required length beforehand, so I would over estimate it length.

However, I come from a C++ background, so normally what I would do there is to pushback a vector, all clean and tidy. But what is the professional way to do this in C? Would you guys pre-allocate or dynamically resize the array?

I am currently using Herbert Schildt's "Turbo C/C++", I'm sure there are much better (and up-to-date) references out there when I get more into things.

Upvotes: 1

Views: 115

Answers (2)

luser droog
luser droog

Reputation: 19494

realloc does everything you're talking about. Allocating an array, growing an array, shrinking an array: it does it all.

int max = 5000; /* why subtract one if you have to add one to use it? */
int *arr = NULL;
int i;

arr = realloc(arr, max * sizeof *arr); /* allocate generous array */
for (i = 0; i < max; i++) {
    /* ... */
}
max = 10000;
arr = realloc(arr, max * sizeof *arr); /* grow array */

max = 100;
arr = realloc(arr, max * sizeof *arr); /* shrink array */

Now there is some popular advice that you should always save the return value from realloc as a separate variable and check it for NULL before overwriting your real pointer variable. This is because there are bizarre situations where the realloc may fail, even on something as innocuous as shrinking an array. This can happen if the malloc subsystem is implemented using fixed-sized buckets, among other possibilities. A shrinking request may fail with a fixed-sized bucket system if there simply aren't any more "small" regions available.

If realloc fails, it returns NULL, but the original allocation is left intact. If you just write the return value into your pointer variable, that data will lost. So, in general, you should try to do this instead:

int *tmp;
tmp = realloc(arr, max * sizeof *arr);
if (tmp) {
    arr = tmp;
} else {
    /* maybe issue an error message? */
}

Upvotes: 1

Survivor
Survivor

Reputation: 672

If you want to allocate the perfect size, you could try this :

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

    int main(){

        int i, j;
        int max = 5000;
        int * ourNumbers = 0;
        int count = 0;

        for(i = 2; i < max; i++){

            if (i % 5 == 0){

                count += 1;
            }
        }

        printf("\ncount = %d\n", count);

        ourNumbers = (int *) malloc(sizeof (int) * count);

        // and after you can populate your array with those values;
        // like this you will allocate the exact memory

    }

I know that is not so efficient, but I hope it will help you :)

Upvotes: 0

Related Questions