J'ai des fonctions pour gérer des listes:
Code :
- list* listNew( );
- void listAddLast( list *l, void *data );
- ...
|
c'est bien joli, mais le contrôle des types est pas terrible et ça oblige à avoir des cast un peu partout.
Maintenant, si j'écris :
Code :
- #define TYPEDEF_LIST_OF( n, t )\
- typedef list list##n;\
- list##n* (* const list##n##New)() = (list##n* (*)())listNew;\
- void (* const list##n##AddLast)( list##n*, t* ) = (void (*)( list##n*, t* )) listAddLast;
|
en ayant:
Code :
- typedef struct{
- int i;
- }toto;
|
je peux "déclarer" un type de liste de toto :
Code :
- TYPEDEF_LIST_OF( Toto, toto );
|
et écrire :
Code :
- listToto *l = listTotoNew();
-
- toto *t = malloc( sizeof(t) );
- t->i = 1;
-
- listTotoAddLast( l, t );
|
en sachant que si j'écrit par exemple:
Code :
- int *i;
- ...
- listTotoAddLast( l, i );
|
gcc me sort un warning.
C'est un peu , mais ça à l'air de marcher à peu près...
Qu'est ce que vous en pensez ? Portatibilité, c'est bien / pas bien, il y a mieux ... ?