les approches modulaires sont assez pratiques en général (portables et propres), donc j'essaie de programmer des modules aussi indépendants que possible des autres modules. La plupart de mes approches sont basées sur une structure qui décrit le module lui-même. Une fonction d'initialisation définit les paramètres principaux, puis un gestionnaire (pointeur vers une structure descriptive) est transmis à la fonction appelée dans le module.
En ce moment, je me demande quelle est la meilleure approche d'allocation de mémoire pour la structure décrivant un module. Si possible, j'aimerais ce qui suit:
- Structure opaque, donc la structure ne peut être modifiée que par l'utilisation des fonctions d'interface fournies
- Plusieurs instances
- mémoire allouée par l'éditeur de liens
Je vois les possibilités suivantes, qui entrent en conflit avec l'un de mes objectifs:
déclaration globale
plusieurs instances, allcoted par l'éditeur de liens, mais la structure n'est pas opaque
(#includes)
module_struct module;
void main(){
module_init(&module);
}
malloc
structure opaque, plusieurs instances, mais allcotion sur le tas
dans module.h:
typedef module_struct Module;
dans la fonction module.c init, malloc et pointeur de retour sur la mémoire allouée
module_mem = malloc(sizeof(module_struct ));
/* initialize values here */
return module_mem;
dans main.c
(#includes)
Module *module;
void main(){
module = module_init();
}
déclaration dans le module
structure opaque, allouée par l'éditeur de liens, uniquement un nombre prédéfini d'instances
garder l'intégralité de la structure et de la mémoire interne au module et ne jamais exposer un gestionnaire ou une struct.
(#includes)
void main(){
module_init(_no_param_or_index_if_multiple_instances_possible_);
}
Existe-t-il une option pour les combiner d'une manière ou d'une autre pour une structure opaque, un éditeur de liens au lieu d'une allocation de tas et plusieurs / un nombre quelconque d'instances?
Solution
comme proposé dans certaines réponses ci-dessous, je pense que la meilleure façon est de:
- réserver de l'espace pour les modules MODULE_MAX_INSTANCE_COUNT dans le fichier source des modules
- ne définissez pas MODULE_MAX_INSTANCE_COUNT dans le module lui-même
- ajoutez une erreur #ifndef MODULE_MAX_INSTANCE_COUNT # au fichier d'en-tête des modules pour vous assurer que l'utilisateur des modules est conscient de cette limitation et définit le nombre maximal d'instances souhaitées pour l'application
- à l'initialisation d'une instance, renvoyez soit l'adresse mémoire (* void) de la structure descriptive, soit l'index des modules (ce que vous préférez)