How to use malloc for an array in struct with unspecified size

I have a struct with arrays that size are not specified.

struct KMData{
    int ndata;
    int dim;
    float **features;
    int *assigns;
    int *labels;
    int nlabels;
};

like this.

In my function below, I try to malloc the memory for features and labels depending on the size of the given file, but it seems like it is not mallocing the size of the data I specified.

struct KMData kmdata_load(char *datafile) {

    ssize_t tokens;
    ssize_t lines;

    filestats(datafile, &tokens, &lines);

    struct KMData *data = malloc(sizeof(struct KMData) + (lines * sizeof(int)) + ((tokens - (2*lines)) * sizeof(float)));
    
    printf("tokens: %zd, lines: %zd\n", tokens, lines);

    data->labels = malloc(lines * sizeof(int));
    data->features = malloc((tokens - (2*lines)) * sizeof(float));

    ssize_t f_size = sizeof(*(data->features));
    printf("size of features: %zd\n", f_size);

    FILE *fin = fopen(datafile, "r");

    char line[3150];

    int i = 0;

    while (fgets(line, 3150, fin)) {

        data->ndata++;
        char *token = strtok(line, " \t");

        data->labels[data->ndata-1] = atoi(token);

        float feats[(tokens/lines)-2];

        int f = 0;
        token = strtok(NULL, " \t");
        while ((token = strtok(NULL, " \t"))) {
            feats[f] = atof(token);
           
            data->features[data->ndata-1][f] = atof(token);

            if(i==0){
                printf("token %d: %f\n", f, data->features[data->ndata-1][f]);
            }
            f++;
        }
        i++;
        ssize_t size = sizeof(feats)/sizeof(float);
       
    }
    fclose(fin);
    
    return *data;
}

int main(int argc, char* argv[]){
  struct KMData data = kmdata_load(argv[1]);
}

Anything that I missed here?

When I print out the size of features, it gives 8, which is way smaller than what I am expecting.

after reading comments and answers, I tried doing

struct KMData *data = malloc(sizeof(struct KMData));
data->labels = malloc(lines * sizeof(int));

then

data->labels[data->ndata-1] = atoi(token);

but it gives me segmentation fault, so am I still not allocating the array correctly?

When a struct contains pointers, you allocate space for just the struct. This will allocate space for the pointers, but they will point at garbage.

struct KMData *data = malloc(sizeof(struct KMData));

Then you allocate space and assign it to the pointers.

data->labels = malloc(lines * sizeof(int));

> When I print out the size of features, it gives 8, which is way smaller than what I am expecting.

The struct only stores the pointer, which on a modern computer is typically 64 bits (8 bytes). That's why sizeof(data->features) is 8. You cannot get the size of the memory allocated to data->features.

Because data->features is a float **, it is a list of pointers. You allocate space for the pointers, then assign existing lists of floats. Allocate with sizeof(float*) times the number of lists you want to store. Then allocate a list of floats.

// Allocate space for a pointer to a list of floats for each line.
data->features = malloc(lines * sizeof(float*));

// Allocate space for each token (a float) in the first line
data->features[0] = malloc(tokens * sizeof(float));

malloc does not clear the allocate memory, it will contain whatever was in it before. Sometimes this is 0, often it is garbage. You also must initialize any members of the struct to be sure.

data->ndata = 0;
data->dim = 0;
data->nlabels = 0;