Returning pointer to pointer of structs - c

Question

I am working on a database which has multiple structs. I have defined a function which loads data from a csv file and stores each line as a struct. I store them using a double pointer, so one pointer points to multiple pointers for each struct variable. The function does return the double pointer correctly, however I get a warning: return from incompatible pointer type.
My code is as follows:
struct part** loadParts(char* fileName, int m)
{
typedef struct part
{
int id;
int cost;
} Part;
FILE* fptr = fopen(fileName, "r");
//creat pointer to array of pointers to part structs
Part** parts;
parts = malloc((nParts) * sizeof(Part *));
//length of one line
char line[1000];
//while new items can be added
int i;
i=0;
while (fgets(line, sizeof(line), fptr)!= NULL)
{
parts[i] = malloc(sizeof(Part));
//get id
int id = atoi(strtok(line, ";"));
parts[i]->id = id;
// get cost
int id = atoi(strtok(line, ";"));
parts[i]->cost = cost;
i++;
}
fclose(fptr);
return parts;
}
Does anybody know why this warning occurs? Many thanks in advance!

Answer 1

You have in outline:
struct part** loadParts(char* fileName, int m)
{
typedef struct part
{
int id;
int cost;
} Part;
…
Part** parts;
…
parts = …
…
return parts;
}
There is no way that this will compile without warnings. The struct part used in the function signature is, by definition, wholly unrelated to the struct part defined inside the function. You are, therefore, returning a pointer to one type in a function that is expecting to return a pointer to a different type, even though those types may both be spelled struct part. There isn't even a way to cast your code out of trouble.
As indicated in the comments, the structure definition must come outside the function, before the function definition (and probably before any declaration — and typically in a header file that's used wherever the structure is used).
One way to fix the code, therefore, is:
typedef struct part
{
int id;
int cost;
} Part;
struct part **loadParts(char *fileName, int m)
{
…
Part **parts;
…
parts = …
…
return parts;
}
You could have the function return a Part ** in this scenario.
However, the function should now be defined as static unless you have a header to contain the structure definition. If you don't have a header, you can't (reliably) access the structure type in other source files. (It can be done by writing the code out twice, but writing code twice should be anathema — it becomes a maintenance liability before you've finished typing, or copy'n'pasting, the second copy.)
It is possible that you are dealing with an opaque type; the code outside this file doesn't need to know about the structure details. That's legitimate; it can even be (very) beneficial. You just need a different way of writing things, though:
Header:
typedef struct part Part;
extern struct part **loadParts(char *fileName, int m);
If you decide not to expose the name Part, you could use this header instead:
struct part;
extern struct part **loadParts(char *fileName, int m);
The first line says "there is a type struct part but the details will be supplied later, if you need them". The second declares the function returning a pointer to pointer to struct part value. The extern is optional; I use it — many people don't. In this code, the first line is optional. However, if you had extern int num_parts(struct part **list); as a function, you would need that to appear after the loadParts() declaration, or you would need the struct part; line to ensure that the type in the prototype is not new.
Source:
struct part
{
int id;
int cost;
};
struct part **loadParts(char *fileName, int m)
{
…
Part **parts;
…
parts = …
…
return parts;
}
You need to worry about header guards in the header to ensure idempotency. (In this example, there's no problem of self-containedness, but you should also ensure that your headers are self-contained — there are multiple questions on SO which will explain those terms if you search).