déclaration de structure

Bonjour,

Je travaille sur un µC, j'ai donc deux zones mémoires pour le stockage de mes données : la ROM et la RAM.

J'ai des éléments qui sont constitués
- nom de l'élément : type string
- description de l'élément : type string
- pointeur de fonction associé a l'élément


donc j'ai créé ma structure comme ceci:

Code:

---

1 2 3 4 5 6 7

typedef struct _structElement { rom char *eltName; rom char *eltDesc; TYPE_FUNC_VOIDVOID *ptr_action; } structElement;

---

Declaration de mon type pointeur de fonction TYPE_FUNC_VOIDVOID :

Code:

---

1 2	typedef void TYPE_FUNC_VOIDVOID(void); // fonction de type : void toto(void)

---

Donc voici comment je déclare un élément :

Code:

---

1 2 3 4

rom const structElement elt1 = { "ma commande1" , "ma description1", toto()}; rom const structElement elt2 = { "ma commande2" , "ma description2", tutu()}; ...

---

la liste de tous mes elements :

Code:

---

1 2	rom structElement *rom tabElt[] = {&elt1, &elt2, ...}

---

Donc pour lancer la commande de l'element 0, je fais :

Code:

---

(*tabElt[0]->ptr_action)();

---

=> pas encore testé



Mon but est d'avoir un tableau qui est composé de ma liste de commande et qu'il soit facile de modifier/ajouter un élément => toutes ces données doivent être stockées en ROM
=> est-ce que vous auriez fait comme ça ?
=> j'ai un doute sur le positionnement des attributs "rom" et "const"...

Attention il me semble qu'il y a une erreur dans ta déclaration du type de pointeur sur fonction, ce serait plutôt :

Code:

---

typedef void (*TYPE_FUNC_VOIDVOID)(void); // fonction de type : void toto(void)

---

du coup, ta struct devient :

Code:

---

1 2 3 4 5 6

typedef struct _structElement { rom char *eltName; rom char *eltDesc; TYPE_FUNC_VOIDVOID ptr_action; } structElement;

---

puisque TYPE_FUNC_VOIDVOID est déjà un pointeur.
De même :

Code:

---

1 2	rom const structElement elt1 = { "ma commande1" , "ma description1", toto}; rom const structElement elt2 = { "ma commande2" , "ma description2", tutu};

---

Pas de parenthèses, sinon, la valeur de toto() c'est la valeur de retour d'une exécution de la fonction toto et non pas l'adresse de la fonction toto.

Enfin pour lancer la commande, c'est :

Code:

---

tabElt[0]->ptr_action();

---

Par contre je ne connais pas le qualificatif rom, je pense que ça doit être spécifique à la plateforme non ?

merci pour ta réponse

rom est spécifique a ma plateforme c'est jsute pour dire que la variable est stockée en rom => mais je crois bien que ça fait la même chose si j'utilise const

par contre es-tu bien sure pour la déclaration du pointeur de fonction ? dans le lien suivant, il n'y a pas de parenthèses :
http://c.developpez.com/faq/?page=ta...dresse_tableau

Citation:

---

Envoyé par huit_six

Attention il me semble qu'il y a une erreur dans ta déclaration du type de pointeur sur fonction, ce serait plutôt :

Code:

---

typedef void (*TYPE_FUNC_VOIDVOID)(void); // fonction de type : void toto(void)

---

du coup, ta struct devient :

Code:

---

1 2 3 4 5 6

typedef struct _structElement { rom char *eltName; rom char *eltDesc; TYPE_FUNC_VOIDVOID ptr_action; } structElement;

---

puisque TYPE_FUNC_VOIDVOID est déjà un pointeur.

---

Donc y avait finalement pas erreur dans l'ancienne déclaration de TYPE_FUNC_VOIDVOID (qui était un type "fonction" et que TU as préféré changé directement en "pointeur de fonction").

Citation:

---

Envoyé par boboss123

Donc pour lancer la commande de l'élément 0, je fais :

Code:

---

(*tabElt[0]->ptr_action)();

---

---

Le déréférencement est inutile.

Code:

---

1 2 3 4 5 6

printf("Vive le C !\n"); (printf)("Vive le C !\n"); (&printf)("Vive le C !\n"); (*printf)("Vive le C !\n"); (**printf)("Vive le C !\n"); (*************printf)("Vive le C !\n");

---

=> C'est la même chose. Voir tutos/FAQs.

merci beaucoup, ça marche

mais auriez vous structuré votre projet de la même manière que ce que je fais la (ça me semble pas mal comme solution) ?

Citation:

---

ça me semble pas mal comme solution

---

En effet :ccool:.

Et bah MINCE alors ! :mrgreen:

Je viens d'apprendre quelque chose ! Je ne savais pas qu'il existait de type fonction ! :oops:

Je n'en avais jamais entendu parler, je manipulais des pointeurs de fonction, mais pas de types fonction.

[Edit] Je suis en train de lire ton cours Melem, je savais bien que j'aurai du le faire avant... :mouarf:

Citation:

---

Envoyé par huit_six

Je n'en avais jamais entendu parler, je manipulais des pointeurs de fonctions, mais pas de types fonction.

---

Si tu ne connaissais pas cette astuce, comment créais tu tes pointeurs de fonctions alors ?
Avant je déclarais mes pointeurs de fonction sur mes structures comme cela :

Code:

---

1 2 3 4 5 6 7 8 9 10

typedef struct _structElement { const char *eltName; const char *eltDesc; const void *ptr_action; // pointeur de fonction } structElement; const structElement elt1; // declaration d'un element const structCmd *const tabElt[]; // tableau de struture   void (*p)(); // pas trop compris comment ça marche lol

---

=> Et depuis que j'ai utilisé la méthode décrite précédemment, j'ai gagné 240 bytes de ROM sur la déclaration/utilisation de ma structure alors que le fonctionnement est le même (ce qui est quand même beaucoup pour mon µC). En plus j'avais des warning sur l'utilisation de la variable p.


-------------------------------
En fait c'est trop bien les pointeurs de fonction, on peut meme faire des gestionnaires d'interruptions:

exemple (pas eu encore le temps de tester) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// ************************* // dans le .h typedef void TYPE_FONCTION(char); // fonction de type : void toto(char xxx) extern void InitModule(TYPE_FONCTION *ptFunc); extern void MyProcess(void);       // ************************* // dans le .c   static TYPE_FONCTION *_ptFunc; static char _state;     // envoi l'interruption static void _SendInterrupt(void){ _ptFunc(_state); }   // initialisation du module void InitModule(TYPE_FONCTION *ptFunc){ _state = 0; _ptFunc = ptFunc; }   // Process du module void MyProcess(void){   .... .... ... if (error){ _SendInterrupt(); }   }     // ************************* // dans l'application   // de static void InterruptDetected(state){   // => traitement de l'interruption   switch (state){ ... ... } }   void main(void){   InitModule(InterruptDetected); // initialisation   while (1){ MyProcess(); // lancement du processus }   }

---

=> c'est bien comme ça qu'on gère les interruptions en c ?

Citation:

---

Si tu ne connaissais pas cette astuce, comment créais tu tes pointeurs de fonctions alors ?

---

Comme dit plus haut ;):

Code:

---

1 2 3 4 5 6 7 8 9

typedef void (*TYPE_FUNC_VOIDVOID)(void);   void fonction_debile(void) { printf("Ceci est la fonction débile\n"); }   TYPE_FUNC_VOIDVOID pointeur_de_fonction = fonction_debile;   pointeur_de_fonction();

---

Code:

---

1 2	void (*p)(void); /* équivaut à : */ TYPE_FUNC_VOIDVOID p;

---

Le typedef permet juste de rendre (beaucoup) plus lisible.

Comme je disais, je connaissais le type pointeur de fonction, mais pas le type fonction. Comme il n'est pas utilisable directement, je n'avais pas encore eu l'occasion de le rencontrer.:mouarf:

Citation:

---

Envoyé par boboss123

En fait c'est trop bien les pointeurs de fonction, on peut meme faire des gestionnaires d'interruptions:

---

ça sert surtout à faire des bibliothèques événementielles, où on enregistre une fonction en fonctions d'événements prévus..

C'est comme ça que marche toutes les biblothèques graphiques.. Quand tu crées un bouton via un IDE, tu as (en général automatiquement) une routine créée qui s'appelera quelque chose comme OnClick(..).

Le Widget a, en interne, une action déjà définie sur le "OnClick" (par exemple inverser les ombres pour faire apparaître que le bouton s'enfonce).

Dans son code, il a aussi un test :

Code:

---

1 2	if ( Registered_Function (WidgetID, ONCLICK) ) Call_Registered-Function ( WidgetID, ONCLICK )

---

ou quelque chose d'équivalent..

ça permet de fabriquer des biblothèques où le programmeur qui va utiliser la bibliothèque peut rajouter des actions à prendre, sans que la bibliothèque soit au courant (et donc sans recompiler).. En général la biblothèque défini cependant une API standard (pour savoi sur quel obket cela s'applique, quelles données (void) elle doit transmettre telles quelles, et vraisemblablement une structure particulière dépendant du type d'objet concerné (par exemple un PushButton n'aura pas la même structure "publique" qu'une liste ou une scrollbar).



C'est l'utilisation la plus courante.

oki merci