Finding size of array of structs C - c

Question

I am trying to find the size of the struct array that I am using to do a sort on it. Not sure how to implement it with the sizeof() function that is normally used in nonstruct arrays.
I am also trying to figure what I am doing wrong when initializing the vehicle struct in the arguments vs the temp struct variable.
error: incompatible types when initializing type ‘struct data *’ using type ‘struct data’
struct data *temp = vehicles[j];
This is the data struct that I am using
struct data{
char *model;
float engineSize;
int cost;
char *color;
};
This is the code that I am currently running for the sort that I am using
void bubbleSortFloats(struct data vehicles[], int check)
{
int i, j, n;
n = sizeof(vehicles)/sizeof(vehicles[0]);
// If check == 1 then ascending sort
if(check == 1){
for (i = 0; i < n-1; i++){
// Last i elements are already in place
for (j = 0; j < n-i-1; j++){
if (vehicles[j].engineSize > vehicles[j+1].engineSize){
struct data temp = vehicles[j];
vehicles[j] = vehicles[j+1];
vehicles[j+1] = temp;
}
}
}
}
// If check == 0 then decending sort
if(check == 0){
for (i = 0; i < n-1; i++){
// Last i elements are already in place
for (j = 0; j < n-i-1; j++){
if (vehicles[j].engineSize < vehicles[j+1].engineSize){
struct data temp = vehicles[j+1];
vehicles[j+1] = vehicles[j];
vehicles[j] = temp;
}
}
}
}
}
This is the update with the readfile function that I am using
struct values * readFile(){
FILE *fp;
int c;
int count = 0;
char *line = NULL;
size_t len = 0;
fp = fopen("hw3.data", "r");
while ((c = fgetc(fp)) != EOF){
if(c == '\n'){
count++;
}
}
if (feof(fp)){
rewind(fp);
struct data *vehicles = malloc((sizeof(struct data))* count);
count = 0;
char *token = NULL;
while (getline(&line, &len, fp)!= -1){
printf("%s", line);
token = strtok(line, " ");
vehicles[count].model = malloc(strlen(token) + 1);
strcpy(vehicles[count].model, token);
token = strtok(NULL, " ");
vehicles[count].engineSize = atof(token);
token = strtok(NULL, " ");
vehicles[count].cost = atoi(token);
token = strtok(NULL, " ");
vehicles[count].color = malloc(strlen(token) + 1);
strcpy(vehicles[count].color, token);
free(line);
line = NULL;
len = 0;
}
struct values *value = malloc(sizeof(struct values));
value.vehicles = vehicles;
value.count = count;
return value;
}

Answer 1

This code
sizeof(vehicles)/sizeof(vehicles[0]);
will only work with true arrays.
In
void bubbleSortFloats(struct data vehicles[], int check);
vehicles look like an array but in fact it is a pointer, this function
definition is the same as
void bubbleSortFloats(struct data *vehicles, int check);
In C you cannot pass true arrays to the functions, they always are passed as
pointers. Even with code like this:
void foo(int arr[10])
{
printf("%lu\n", sizeof arr / sizeof *arr);
}
int main()
{
int arr[10] = { 0 };
foo(arr);
}
I get a warning of my compiler:
a.c: In function ‘foo’:
a.c:6:25: warning: ‘sizeof’ on array function parameter ‘arr’ will return size of ‘int *’ [-Wsizeof-array-argument]
printf("%lu\n", sizeof arr);
^~~
a.c:4:14: note: declared here
void foo(int arr[10])
^~~
and if I execute it, I get 2, because on my system the size of a pointer is 8
and the size of an int is 2. That's why the sizeof arr / sizeof *arr doesn't
work in a function that gets an array passed.
You have to calculate the length of the array before you call
bubbleSortFloats and pass that length to the function. The correct function
would be:
void bubbleSortFloats(struct data *vehicles, size_t len, int check)
{
...
}
We don't see how you created the array, but the function that creates it will
know the size:
void foo(void)
{
struct data vehicles[SOME_LEN];
...
bubbleSortFloats(vehicles, sizeof vehicles / sizeof *vehicles, check);
}
or if you did it with malloc
void foo(void)
{
size_t len = ...;
struct data *vehicles = malloc(len * sizeof *vehicles);
if(vehicles == NULL)
return;
...
bubbleSortFloats(vehicles, len, check);
}
edit
Jeffrey Hennen asked in the comment section:
I made it clear. I am going to want to return a structure and an int count for the size of the array of structures
Like I said in the comments, if you want to return more than one value, you have
essentially two options:
Declare a struct that encapsulates all the returning values and return it
Or pass pointers to the function and let the function update the values
provided by the pointers.
You've chosen way 1, so I guess you have this struct:
struct values {
struct data *vehicles;
size_t count;
};
Then the way you are returning it, is OK. Of course you should check that the
last malloc did not return NULL (you are ignoring that throughout the whole
function, though).
The second option would be:
The easiest way would be:
struct data *readFile(size_t *length) {
if(length == NULL)
return NULL;
...
while (getline(&line, &len, fp)!= -1){
...
};
// NOT NEEDED ANYMORE
//struct values *value = malloc(sizeof(struct values));
//value.vehicles = vehicles;
//value.count = count;
*length = count; // UPDATE the length through the pointer
return vehicles; // return the array
}
and the calling function would do:
void foo(void)
{
size_t count;
struct data *vehicles = readFile(&count);
if(vehicles == NULL)
{
// error
return;
}
do_something_with_the_vehicles(vehicles, count);
free_the_vehicles(vehicles, count);
}
Of course you would have to write a function free_the_vehicles (you can of
course choose another name) that frees all the memory allocated.

Answer 2

struct data *temp = &vehicles[j];
Otherwise it is incompatible as you try to assign the pointer with the structure. You need to assign the address of the structure

Answer 3

When copying a struct, a direct assignment does not work.
Suggest using the function: memcpy().
memcpy( temp, &vehicles[j], sizeof( struct data );
similar considerations exist for all the statements that are trying to copy the 'struct data' instances