Load Structs in C - c

Question

In my header file I have defined some structs:
typedef struct { double X; } feature_t;
typedef struct
{
int n;
feature_t *Features;
float *Weights;
} signature_t;
In my main code I declare some new structs and try to load them:
feature_t *f_x;
int i;
memset(f_x,0,sizeof(feature_t)*n_x);
for(i=0; i<n_x; i++){
f_x[i] = 100.0;
w_x[i] = (float)p_x[i];
}
When I go to compile this, I get the following error:
error: incompatible types when assigning to type ‘feature_t {aka struct <anonymous>}’ from type ‘double’
Why does the compiler having trouble loading this double into this field? I declared it as a double.
thanks!

Answer 1

There is a compile problem and a run-time problem that needs to be fixed once the compile problem is out of the way.
The compile problem is that you cannot cast a float to a struct, even when the struct's only field is a float. You need to assign it like this:
f_x[i].X = ... // some float expression here
The run-time problem is that feature_t *f_x; pointer cannot be used like an array until you assign it some memory. Recall that pointers are not arrays. You need to do something like this:
feature_t *f_x = malloc(sizeof(*f_x)*n_x);

Answer 2

You have two options:
The first: make your feature_t instance an "automatic" variable on the stack - so no extra work needs to be done, but you can't use the object from the caller of the function that creates it:
void doSomething(size_t n) {
struct feature_t f_x[n];
for(size_t i = 0; i < n; i++) {
f_x[i] = {};
f_x[i].X = 100.0;
}
}
(Note the above example uses a VLA, this is not permitted in C++, only C99)
Because f_X lives in the stack, the = {} initialization syntax means the raw object data in the stack is zeroed out.
(Note that you cannot use the ={} syntax to initialize a VLA, each element must be initialized individually)
The second is to use the heap, but you must ensure you deallocate the memory eventually otherwise it will be a memory leak:
void doSomething(size_t n) {
struct feature_t* f_x = calloc( n, sizeof(struct feature_t) );
if( f_x == NULL ) exit( EXIT_FAILURE );
for(size_t i = 0; i < n; i++) {
f_x[i].X = 100.0;
}
free( f_x );
}
In this case, f_x is actually a pointer to the array of feature_t instances that lives on the heap, so its lifespan is potentially beyond the doSomething function scope - however I called free before the function returned.
I used calloc which allocates and zeroes-out memory before returning control to the caller, whereas malloc only allocates memory and exposes what memory contents were there previously, which is generally undesirable unless you absolutely need the performance gains by not explicitly zeroing memory.