C：malloc'ed指针从函数返回后改变位置？

Question

I have a function that creates and returns a double* , but the location seems to change after I return it from the function, which leads to a seg fault.

void get_data_internal(double* data, int64_t* i, Factor* fctr) {
    if (fctr->factor_type == DATA_PT) {
        data[*i] = get_factor_data_pt(fctr);
        (*i)++;
    }
    else {
        stSetIterator* child_iter = stSet_getIterator(get_factor_children(fctr));
        Factor* child_fctr = stSet_getNext(child_iter);
        while (child_fctr != NULL) {
            get_data_internal(data, i, child_fctr);
            child_fctr = stSet_getNext(child_iter);
        }
    }
}

double* get_data(HierarchicalDirichletProcess* hdp) {
    int64_t data_length = hdp->data_length;
    double* data = (double*) malloc(sizeof(double) * data_length);

    int64_t i = 0;
    stSetIterator* base_fctr_iter = stSet_getIterator(hdp->base_dp->factors);
    Factor* base_fctr = stSet_getNext(base_fctr_iter);
    while (base_fctr != NULL) {
        get_data_internal(data, &i, base_fctr);
        base_fctr = stSet_getNext(base_fctr_iter);
    }

    printf("returning data at address %p\n", data);
    return data;
}

This gets called from

double* data = get_data(hdp);
printf("receiving data at address %p\n", data);

Which prints

returning data at address 0x10c343000
receiving data at address 0xc343000

In every case, the address inside the function is 0x100000000 greater than the address outside the function. What am I missing here?

Answer 1

Perhaps there is no prototype in scope at the point of the call:

double* data = get_data(hdp);

In this case the compiler would assume the function returns int and so generate the wrong code for handling the return value.

If so, there should be at least two error or warning messages generated - check your compiler output.