Opaque C structs: comment doivent-elles être déclarées?

Mon vote est pour la troisième option qui mouviciel posté puis supprimé:

J'ai vu une troisième voie:

//foo.h
struct foo;
void doStuff(struct foo *f);

//foo.c
struct foo {
    int x;
    int y;
};

Si vous ne pouvez vraiment pas se tenir en tapant le struct mot-clé, typedef struct foo foo; (note: se débarrasser de l'inutile et de la problématique de soulignement) est acceptable. Mais quoi que vous fassiez, jamais utilisation typedef à définir des noms pour les types de pointeur. Il masque l'extrême importance de l'information que les variables de ce type de référence d'un objet qui pouvait être modifié chaque fois que vous passez à des fonctions, et il le fait de traiter différemment qualifiés (par exemple, constqualifié) versions de l'aiguille d'une grande douleur.

Option de 1,5

Je suis habitué à utiliser Option 1, sauf votre nom, votre référence avec _h pour indiquer qu'il s'agit d'une "poignée" d'un style C "objet" de cette manière, C "classe". Ensuite, vous assurer que vos prototypes de fonction utilisation const où le contenu de cet objet "poignée" est une entrée uniquement, et ne peut pas être modifié, et ne pas utiliser const où le contenu peut être changé.

Voici un exemple complet:

//======================================================================================================================
//my_module.h
//======================================================================================================================
//An opaque pointer (handle) to a C-style "object" of "class" type "my_module" (struct my_module_s *, or my_module_h):
typedef struct my_module_s *my_module_h;
//Create a new "object" of "class" "my_module":
//A function that takes a *pointer to* an "object" handle, `malloc`s memory for a new copy of the opaque 
//`struct my_module_s`, then points the user's input handle (via its passed-in pointer) to this newly-created 
//"object" of "class" "my_module".
void my_module_open(my_module_h * my_module_h_p);
//A function that takes this "object" (via its handle) as an input only and cannot modify it
void my_module_do_stuff1(const my_module_h my_module);
//A function that can modify the private content of this "object" (via its handle) (but still cannot modify the 
//handle itself)
void my_module_do_stuff2(my_module_h my_module);
//Destroy the passed-in "object" of "class" type "my_module":
//A function that can close this object by stopping all operations, as required, and `free`ing its memory.
//`struct my_module_s`, then points the user's input handle (via its passed-in pointer) to this newly-created "object".
void my_module_close(my_module_h my_module);
//======================================================================================================================
//my_module.c
//======================================================================================================================
//Definition of the opaque struct "object" of C-style "class" "my_module".
//- NB: Since this is an opaque struct (declared in the header but not defined until the source file), it has the 
//following 2 important properties:
//1) It permits data hiding, wherein you end up with the equivalent of a C++ "class" with only *private* member 
//variables.
//2) Objects of this "class" can only be dynamically allocated. No static allocation is possible since any module
//including the header file does not know the contents of *nor the size of* (this is the critical part) this "class"
//(ie: C struct).
struct my_module_s
{
int my_private_int1;
int my_private_int2;
float my_private_float;
//etc. etc--add more "private" member variables as you see fit
}
void my_module_open(my_module_h * my_module_h_p)
{
//Ensure the passed-in pointer is not NULL (since it is a core dump/segmentation fault to try to dereference 
//a NULL pointer)
if (!my_module_h_p)
{
//Print some error or store some error code here, and return it at the end of the function instead of 
//returning void.
goto done;
}
//Now allocate the actual memory for a new my_module C object from the heap, thereby dynamically creating this
//C-style "object".
my_module_h my_module; //Create a local object handle (pointer to a struct)
my_module = malloc(sizeof(*my_module)); //Dynamically allocate memory for the full contents of the struct "object"
if (!my_module) 
{
//Malloc failed due to out-of-memory. Print some error or store some error code here, and return it
//at the end of the function instead of returning void.
goto done;
}
//Initialize all memory to zero (OR just use `calloc()` instead of `malloc()` above!)
memset(my_module, 0, sizeof(*my_module));
//Now pass out this object to the user, and exit.
*my_module_h_p = my_module;
done:
}
void my_module_do_stuff1(const my_module_h my_module)
{
//Ensure my_module is not a NULL pointer.
if (!my_module)
{
goto done;
}
//Do stuff where you use my_module private "member" variables.
//Ex: use `my_module->my_private_int1` here, or `my_module->my_private_float`, etc. 
done:
}
void my_module_do_stuff2(my_module_h my_module)
{
//Ensure my_module is not a NULL pointer.
if (!my_module)
{
goto done;
}
//Do stuff where you use AND UPDATE my_module private "member" variables.
//Ex:
my_module->my_private_int1 = 7;
my_module->my_private_float = 3.14159;
//Etc.
done:
}
void my_module_close(my_module_h my_module)
{
//Ensure my_module is not a NULL pointer.
if (!my_module)
{
goto done;
}
free(my_module);
done:
}

La seule amélioration au-delà de ce qui serait d':

1. Mettre en œuvre complète de la gestion d'erreur et renvoie l'erreur au lieu de void.

2. Ajouter une configuration struct appelé my_module_config_t à l' .h de fichier, et de le transmettre à la open fonction de mise à jour des variables internes lorsque vous créez un nouvel objet. Exemple:

   //--------------------
   //my_module.h
   //--------------------
   //my_module configuration struct
   typedef struct my_module_config_s
   {
   int my_config_param_int;
   int my_config_param_float;
   } my_module_config_t;
   void my_module_open(my_module_h * my_module_h_p, const my_module_config_t *config);
   //--------------------
   //my_module.c
   //--------------------
   void my_module_open(my_module_h * my_module_h_p, const my_module_config_t *config)
   {
   //Ensure the passed-in pointer is not NULL (since it is a core dump/segmentation fault to try to dereference 
   //a NULL pointer)
   if (!my_module_h_p)
   {
   //Print some error or store some error code here, and return it at the end of the function instead of 
   //returning void.
   goto done;
   }
   //Now allocate the actual memory for a new my_module C object from the heap, thereby dynamically creating this
   //C-style "object".
   my_module_h my_module; //Create a local object handle (pointer to a struct)
   my_module = malloc(sizeof(*my_module)); //Dynamically allocate memory for the full contents of the struct "object"
   if (!my_module) 
   {
   //Malloc failed due to out-of-memory. Print some error or store some error code here, and return it
   //at the end of the function instead of returning void.
   goto done;
   }
   //Initialize all memory to zero (OR just use `calloc()` instead of `malloc()` above!)
   memset(my_module, 0, sizeof(*my_module));
   //Now initialize the object with values per the config struct passed in.
   my_module->my_private_int1 = config->my_config_param_int;
   my_module->my_private_int2 = config->my_config_param_int*3/2;
   my_module->my_private_float = config->my_config_param_float;        
   //etc etc
   //Now pass out this object to the user, and exit.
   *my_module_h_p = my_module;
   done:
   }