Discussion :

[contremaitre]

Bonjour,

J'ai besoin d'écrire des fonctions de callback, et comme il y en a beaucoup, pour plus de clarté, j'aimerais les écrire dans un fichier séparé.
Mais ce sont des fonctions "static".
Comment faire ?

merci

[ram-0000]

Pour quelle raison elles sont "static"

En général, en C, quand on rend une fonction static, c'est pour la rendre non visible d'un autre module C

que ces fonctions soient des callback ne devrait avoir aucun impact sur leur visibilité static ou non

[Melem]

Elles sont statiques car on veut avoir des fonctions de même nom dans des fichiers sources différents. Mais je n'ai rien compris à la question, si une fonction fait référence à une fonction callback (statique), les deux doivent simplement se trouver dans le même fichier source ...

[ram-0000]

On peut aussi imaginer une autre solution :

tu mets tes fonctions de callback dans un module à part et tu les rends statiques.

Dans ce même module, tu ajoutes une fonction non statique qui te retourne un tableau de pointeurs de fonction sur tes fonction callback. Cela suppose que tes fonctions callback on toute le même prototype.

Dans le cas contraire (pas le même prototype), tu retournes une structure de pointeurs de fonction.

[contremaitre]

Elles sont statiques car on veut avoir des fonctions de même nom dans des fichiers sources différents. Mais je n'ai rien compris à la question, si une fonction fait référence à une fonction callback (statique), les deux doivent simplement se trouver dans le même fichier source ...

Elles sont statics car elles ne sont utilisées nulle part ailleurs. Et je voulais separer les fichiers pour plus de clarté car il y en a beaucoup.

tu mets tes fonctions de callback dans un module à part et tu les rends statiques.

Dans ce même module, tu ajoutes une fonction non statique qui te retourne un tableau de pointeurs de fonction sur tes fonction callback. Cela suppose que tes fonctions callback on toute le même prototype.

Dans le cas contraire (pas le même prototype), tu retournes une structure de pointeurs de fonction.

Comme le but était de de simplifier la chose, malheueresement cette solution est un peu compliquée

Sinon je peux peut etre ecrire les fonctions en question dans un .h et l'inclure seulement là ou je m'en sert ?
mais c'est peut etre pas conseillé de faire comme ca ?

[ram-0000]

Définir quelquechose dans un .h, c'est mal

On définit dans un .c et on déclare dans le .h (si besoin est)

[3DArchi]

En reprenant l'idée de Ram :
interface.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
typedef struct {
   void (*fonction_1)();
   void (*fonction_2)();
   void (*fonction_3)();
} stInterface;
 
void InitialiserInterface(stInterface*pItf_);

interface.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include "interface.h"
 
static void ma_fonction_1();
static void ma_fonction_2();
static void ma_fonction_3();
 
void InitialiserInterface(stInterface*pItf_)
{
   pItf_->fonction_1 = ma_fonction_1;
   pItf_->fonction_2 = ma_fonction_2;
   pItf_->fonction_3 = ma_fonction_3;
}
 
static void ma_fonction_1()
{
   /* traitement */
}
 
static void ma_fonction_2()
{
   /* traitement */
}
 
static void ma_fonction_3()
{
   /* traitement */
}

Exemple d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
int main(){
stInterface mon_interface;
   InitialiserInterface(&mon_interface);
   mon_interface.fonction_1();
   mon_interface.fonction_2();
   mon_interface.fonction_3();
	return 0;
 
}

[matafan]

Tu peux tout à fait, via un pointeur de fonction, appeler une fonction qui est définie "static" dans une autre fichier source. Le fait que la fonction soit "static" ne change rien.

[souviron34]

Absolument..

Mais je pense que de toutes façons le problème de départ n'étant pas clair, au vu du niveau, je ne pense pas qu'il faille en arriver là..

Je pense que le PO a tout simplement un problème de conception... Qu'il doit fouiller et nous expliquer plus clairement

[contremaitre]

Pour préciser le problème :
J'utilise la libraire C sqlite3 pour faire des requêtes SQL.
Et dans un fichier j'ai des fonctions qui font la liaison entre mon application et sqlite.

Ex : Imaginons une base de données avec des utilisateurs, j'ai alors une fonction qui s'appelle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int getIdUtilisateur(const char *nom)
{
     [...]
     sqlite3_exec(... , callback1, ...);
     [...]
}

Dans une fichier requetes_base.c

Et j'ai plusieurs dizaine de fonctions comme ça.

Le problème c'est que pour chaque fonction, il y a une requête SQL différente, et donc un callback différent pour chaque requête.

Pour faciliter la lecture et la modification de ce fichier je voulais mettre les callbacks dans un fichier à part, car une fois écrit ils changent rarement.

[souviron34]

alors la meilleure solution est du style présentée ci-dessus..

Pour faire quelque chose de vraiment propre, quelque chose dans le style irait bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
typedef int Ma_Proc(void *client, void *cbstruct);
 
typedef struct pMa_Fct {
 
      int       functiontype ;
      Ma_Proc   *adr ;
      void      *data ;
 
} Ma_Fct ;

Suivi d'un module de gestion de ces fonctions (dont voici un exemple de .h) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
extern int     RegisterFunction         ( int functiontype,
                                          Ma_Proc Adr, void *data );
 
extern Boolean CheckIfRegisteredFunction( int functiontype );
 
extern int     CallRegisteredFunction   ( int functiontype,
  			                  void *FctStruct);
 
extern int     RemoveRegisteredFunction ( int functiontype, 
                                          MCore_Proc Adr, void *data );

Puis tu l'utilises en ayant dans ton module principal un "Init_Callbacks (qui serait déclaré en externe dans ton Callbacks.h)

Puis dans ton callbacks.c, tu as tes callbacks statiques, puis la fonction Init_Callbacks, du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static int MaPremiereCallback ( void *cdata, void *cstruct)
{
   MonData *LocalData = (MonData *) cdata ;
 
   ....
}
 
int Init_Callbacks ( struct MonData *MesData )
{
   int i, ss=0 ;
 
   i = RegisterFunction (MAPREMIEREREQUETE_ID, MaPremiereCallback, (void *)MesData);
   .......
}

et dans tes modules extérieurs (style ton main) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
       if ( CheckIfRegisteredFunction( MAPREMIEREREQUETE_ID ))
        {
	  k = CallRegisteredFunction ( MAPREMIEREREQUETE_ID, (void *)&MonDataLocal );
        }

Bien sûr, il te faudra définir toutes tes requêtes ou types de callbacks possibles dans un .h (les #define MAPREMIREREQUETE_ID)

[contremaitre]

ok, merci à tous pour les infos.