Thread: Returning pointer to dynamically created int array from function

I am trying to return a pointer to a dynamically created array of ints from a function. Right now the array values should be the same as their index. so data[3] = 3.... Eventually this array will be filled with primes from some sieve code that I have already written, but I need to get this function framework working. It currently compiles without warning, but seg faults. Thanks to dwks who wrote nearly all of this code.

Code:

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

int *getPrimes(int *count, int max)
{
        int size = 10;  // this keeps track of how many elements are allocated
        int *array = malloc(size * sizeof(*array));
        *count = 0;  // this keeps track of how many elements are used, so *count <= size at all times

        int x;
        for( x = 0 ; x < max ; x++ )
        {
                // assume x needs to be added to the array.
                if(*count + 1 > size)
                {
                        // not enough space.
                        size *= 2;
                        array = realloc(array, size * sizeof(*array));
                }
        array[*count] = x;
        *count ++;
        }
    return array;
}



int main(void)
{
        int n = 300;
        int count;
        int *data = getPrimes(&count, n);
        printf("data0 is %i", data[0]);

        return 0;
}

That did it. Although I'm just not sure why. What does *count++ do? Why doesn't it increase the value of what count points to?

If you're busy don't worry about it, it works, now I just have to graft in the sieve code and I'm good to go.

Oh, where are my manners, thank you very much Laserlight

Code:

*count++;

is the same as

Code:

*(count++); /* the de-reference is ignored, just as if you had a statement "42;" */

To clarify a bit on why your original code, and Salem's and Laser's code work the way they do:

C Operator Precedence Table

Take a close look. The postfix ++ has higher precedence than the prefix ++ or dereference (unary *). That means it happens before the dereference, so

Code:

*count++
// and
*(count++)

are effectively the same, but what you wanted is to dereference first, then increment:

Code:

(*count)++

which is what Salem suggested.

Laserlight's suggestion of moving the ++ to a prefix/preincrement has the same effect, so

Code:

++*count
//and
++(*count)

are effectively the same. That's because of the operator associativity. Note that prefix ++ and dereference have the same precedence. So which one do we do first? Prefix operators (which are inherently unary) are among the few that are actually right-to-left associative. Meaning you evaluate the expression from right to left.

It can get a bit more complicated when you have long expressions with operators that have both R-to-L and L-to-R associativity. Keeping track of what is going on can be tough, especially if you don't have the table fully memorized. That's why I always recommend to use parentheses to ensure you get the order you want (but don't overdo it). If you want to increment what count points to, then put what count points to in parentheses (*count) and increment that. Then it doesn't matter whether use use prefix or postfix increment, and you don't have to worry so much about operator precedence and associativity.

That helps a lot, seeing it from a viewpoint of precedence makes it clearer.