C, generalize functions argument's type - c

Question

I was writing a c library for linked lists and trees and i was looking for a solution to generalize the data type handled by these libraries without making a list/tree library for each type i need to handle.
For example, my list library has these functions:
/* list.h */
typedef int list_element; // <-- need to generalize that
struct list_node {
list_element value;
struct list_node* next;
};
typedef struct list_node list_node;
typedef struct list_node* list;
extern list list_cons(list_element d, list l)
And then my list.c:
/* list.c */
#include <list.h>
list list_cons(list_element d, list l){
list m = malloc(sizeof(list_node));
m->value = element_copy(d);
m->next = l;
return m;
}
Now suppose that in my main program i've to use a list of int and a list of double, i should create 2 couple of file, something like list_float.c/.h and list_int.c/.h
Also some list_element can be struct and need functions like copy/isLess/isEqual to compare themselves
I want to write something like this in my code:
/* main.c */
list_cons(void *data, list l);
Where data is a pointer to any type i want and inside list_cons, element_copy work for any type of data i pass (obviously i need to copy the data not the pointer to data, void* is the only idea i had to generalize the argument's type of a function)

Answer 1

As a general suggestion, you should not assume that list_cons would be the only way to construct a linked list. Sometimes malloc is just not available or user wants to preallocate everything in a static array or wants to use custom allocator or...
As a concrete sample, you may look at https://github.com/torvalds/linux/blob/master/include/linux/list.h.
If you want other license for your code, search for data structure implementations in xBSD Unix sources.
The general idea is that you only require a linked list structure to contain next/prev and similar fields, not limiting user to your type names. All iterations and basic operations are defined as preprocessor macros, on top of which you implement complex algorithms.

Answer 2

Notice that in C11 (read its standard n1570 and some C reference site) different types can be handled differently (see its §6.5.2).
In particular, the implementation can handle int, double and pointer values differently (their size and alignment is often different, see sizeof & alignof), and some ABI conventions decide that they are passed in different registers (e.g. in function calls).
So you cannot write something which handles (portably) all of int, double etc... the same way (unless you have variadic functions; with <stdarg.h>)
You might decide to implement some "generic" list whose content is some arbitrary pointer. But then you need some conventions about them (who is allocating that pointer, who is freeing it, perhaps what operations are allowed, etc...). Look into Glib doubly-linked lists for inspiration.
You could also use preprocessor techniques to generate an abstract data type (of your list) and functions implementing it, given some type name for the content. Look into SGLIB for inspiration.
You could also use some metaprogramming techniques: you'll describe somehow the type of the element, and you feed that description into your metaprogram which is some C code generator. Look into SWIG for inspiration. The generated C code would implement your list's abstract data type.
Don't forget memory management issues and describe and document clearly your conventions around them. Read about RAII.
Think also of complex cases like some list of list of strings (perhaps dynamically allocated à la strdup or obtained using asprintf). You'll discover that things are not simple, and you'll need to explicit conventions (e.g. could some string be shared between two sublists? When would that string be free-d, ...).

Answer 3

This might be a good place to use a union.
You can define your base datatype as a union of the most common types you want to support. Then you would define a enum of the types in question as use that value to flag what the union contains.
enum element_type {
TYPE_INT,
TYPE_DOUBLE
};
typedef union {
int e_int;
double e_double;
} list_element;
struct list_node {
enum element_type type;
list_element value;
struct list_node* next;
};
Then you add to the list like this:
list list_cons(list_element d, enum element_type type, list l){
list m = malloc(sizeof(list_node));
m->type = type;
m->value = element_copy(d);
m->next = l;
return m;
}