Définir des fonctions static dans un fichier séparé.

Version imprimable

03/02/2009, 09h22
contremaitre

Définir des fonctions static dans un fichier séparé.

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
03/02/2009, 09h26
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
03/02/2009, 09h31
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 ...
03/02/2009, 09h36
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.
03/02/2009, 09h46
contremaitre

Citation:

Envoyé par 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 ...

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.

Citation:

Envoyé par ram-0000

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 ?
03/02/2009, 10h04
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)

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

Code:

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:

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:

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;
 
}

03/02/2009, 13h04
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.
03/02/2009, 13h18
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 :D
03/02/2009, 14h09
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:

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.

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:

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:

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:

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:

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)

:D

04/02/2009, 17h14
contremaitre

ok, merci à tous pour les infos.