Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en cours
d'exécution aient leur variable externe utilisée exclusivement des autres
par une bibliothèque dynamique unique en mémoire ?
Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en cours
d'exécution aient leur variable externe utilisée exclusivement des autres
par une bibliothèque dynamique unique en mémoire ?
Bonjour,
Je veux utiliser une variable externe dans un programme pour qu'elle soit
utilisée par des fonctions appartenant à une bibliothèque dynamique.
Car j'ai déjà codé ces fonctions et elles sont assez nombreuses. Et je ne
veux pas leurs passer ma variable en paramètre car esthétisme de mon
programme en serait changé.
Comment dois-je déclarer ma variable dans mon programme et dans ma
bibliothèque et/ou son en-tête ?
Puis-je avoir l'assurance que plusieurs instances de mon programme en cours
d'exécution aient leur variable externe utilisée exclusivement des autres
par une bibliothèque dynamique unique en mémoire ?
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
test de réponse
test de réponse
test de réponse
Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Zanner La Glauje wrote:
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Zanner La Glauje wrote:
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire (d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau) est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système (en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Antoine
Bonjour,
Antoine Leca a écrit:Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée
même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire
(d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont
généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au
cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y
a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau)
est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuels
Voir plus bas j'ai testé la solution Windows XP
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie
à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
d'erreur propre au programme qui a fait appel à la fonction à l'origine
de l'erreur.b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
Antoine
La solution que j'ai retenu pour l'instant est :
---bibliotheque.h----
#include <stdlib>
void fnLibererErreurDuServeur();
void fnTestErreurDuServeur();
char *fnObtenirErreurDuServeur();
...
---------------------
---bibliotheque.c----
#include "bibliothèque.h"
char *errbuff=NULL;
/*fonctions permettant d'y accéder*/
void fnLibererErreurDuServeur()
{
free(errbuf);
errbuf=NULL;
}
void fnTestErreurDuServeur() {
errbuf="tralalalalalala";
}
char *fnObtenirErreurDuServeur() {
return errbuf;
}
/* et d'autres fonctions qui accèdent à errbuf comme
fnTestErreurDuServeur() en cas d'erreur par exemple d'un malloc ou
d'erreur à l'ouverture d'une base de données*/
...
---------------------
---programme.c-------
#include "bibliothèque.h"
int main() {
/* appel de fonctions de bibliotheque.c*/
if(fnObtenirErreurDuServeur()) {
/*j'ai un problème sur le serveur*/
}
return 0;
}
---------------------
bibliotheque.c est "compilé" pour être une bibliothèque dynamique.
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?
J'utilise Windows XP.
Ps : Merci, messieurs.
Cordialement,
ZannerLaGlauje,
"0=0 <=> 0=1 mille feuilles entamé + un toto qui a moins faim."
Bonjour,
Antoine Leca a écrit:
Zanner La Glauje wrote:
Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée
même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire
(d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont
généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au
cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y
a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau)
est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuels
Voir plus bas j'ai testé la solution Windows XP
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie
à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
d'erreur propre au programme qui a fait appel à la fonction à l'origine
de l'erreur.
b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).
Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
Antoine
La solution que j'ai retenu pour l'instant est :
---bibliotheque.h----
#include <stdlib>
void fnLibererErreurDuServeur();
void fnTestErreurDuServeur();
char *fnObtenirErreurDuServeur();
...
---------------------
---bibliotheque.c----
#include "bibliothèque.h"
char *errbuff=NULL;
/*fonctions permettant d'y accéder*/
void fnLibererErreurDuServeur()
{
free(errbuf);
errbuf=NULL;
}
void fnTestErreurDuServeur() {
errbuf="tralalalalalala";
}
char *fnObtenirErreurDuServeur() {
return errbuf;
}
/* et d'autres fonctions qui accèdent à errbuf comme
fnTestErreurDuServeur() en cas d'erreur par exemple d'un malloc ou
d'erreur à l'ouverture d'une base de données*/
...
---------------------
---programme.c-------
#include "bibliothèque.h"
int main() {
/* appel de fonctions de bibliotheque.c*/
if(fnObtenirErreurDuServeur()) {
/*j'ai un problème sur le serveur*/
}
return 0;
}
---------------------
bibliotheque.c est "compilé" pour être une bibliothèque dynamique.
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?
J'utilise Windows XP.
Ps : Merci, messieurs.
Cordialement,
ZannerLaGlauje,
"0=0 <=> 0=1 mille feuilles entamé + un toto qui a moins faim."
Bonjour,
Antoine Leca a écrit:Zanner La Glauje wrote:Je veux utiliser une variable externe dans un programme pour qu'elle
soit utilisée par des fonctions appartenant à une bibliothèque
dynamique.
En général c'est une mauvaise idée (sans parler du fait que l'idée
même de
variable globale n'est pas vraiment une bonne idée en 2007). Les
bibliothèques dynamiques ont été inventées pour partager la mémoire
(d'où le
nom anglais de /shared object/, objet partagé). Pas de problème pour
partager un objet invariant comme du code, mais c'est nettement moins
adaptées pour un objet qui peut être modifié comme le sont
généralement les
variables.
Si en fait ta variable est une constante (elle ne varie donc pas au
cours du
temps) et qu'il y a une seule bibliothèque dynamique partagée, il n'y
a pas
de gros souci en perspective. Le plus simple (mais pas le plus beau)
est de
remplacer
extern type ma_var;
par
extern type _cachemoi_ma_var(void);
#define ma_var (_cachemoi_ma_var())
et dans la bibliothèque dynamique écrire la fonction
/*globale*/ type ma_var_ici={0};
type _cachemoi_ma_var(void) { return ma_var_ici; }
Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques,
ou une constante dont la valeur dépend de chaque programme, c'est plus
coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros
il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuels
Voir plus bas j'ai testé la solution Windows XP
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
b) et aussi cela dépend du choix que tu dois faire d'avoir ta variable:
b.1- unique par instance, donc chaque programme/processus qui se lie
à la
bibliothèque voit une version différente de la variable; c'est ce qui se
passe pour errno, par exemple;
oui errno est mon cas d'utilisation de ma variable partagée : un message
d'erreur propre au programme qui a fait appel à la fonction à l'origine
de l'erreur.b.2- ou bien une variable partagée (et des joies en perspective pour la
synchronisation).Puis-je avoir l'assurance que plusieurs instances de mon programme en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De
plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
Antoine
La solution que j'ai retenu pour l'instant est :
---bibliotheque.h----
#include <stdlib>
void fnLibererErreurDuServeur();
void fnTestErreurDuServeur();
char *fnObtenirErreurDuServeur();
...
---------------------
---bibliotheque.c----
#include "bibliothèque.h"
char *errbuff=NULL;
/*fonctions permettant d'y accéder*/
void fnLibererErreurDuServeur()
{
free(errbuf);
errbuf=NULL;
}
void fnTestErreurDuServeur() {
errbuf="tralalalalalala";
}
char *fnObtenirErreurDuServeur() {
return errbuf;
}
/* et d'autres fonctions qui accèdent à errbuf comme
fnTestErreurDuServeur() en cas d'erreur par exemple d'un malloc ou
d'erreur à l'ouverture d'une base de données*/
...
---------------------
---programme.c-------
#include "bibliothèque.h"
int main() {
/* appel de fonctions de bibliotheque.c*/
if(fnObtenirErreurDuServeur()) {
/*j'ai un problème sur le serveur*/
}
return 0;
}
---------------------
bibliotheque.c est "compilé" pour être une bibliothèque dynamique.
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?
J'utilise Windows XP.
Ps : Merci, messieurs.
Cordialement,
ZannerLaGlauje,
"0=0 <=> 0=1 mille feuilles entamé + un toto qui a moins faim."
Antoine Leca a écrit:Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques, ou une constante dont la valeur dépend de chaque
programme, c'est plus coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement
pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuelsa.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
Puis-je avoir l'assurance que plusieurs instances de mon programme
en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
La solution que j'ai retenu pour l'instant est :
<couic>
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?
Antoine Leca a écrit:
Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques, ou une constante dont la valeur dépend de chaque
programme, c'est plus coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement
pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuels
a.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
Puis-je avoir l'assurance que plusieurs instances de mon programme
en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
La solution que j'ai retenu pour l'instant est :
<couic>
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?
Antoine Leca a écrit:Si tu veux une variable qui se modifie vraiment, ou plusieurs
bibliothèques, ou une constante dont la valeur dépend de chaque
programme, c'est plus coton, la manière de procéder dépend:
a) de l'implémentation des bibliothèques dynamiques sur ton système
(en gros il y a trois cas,
a.1- la solution "COFF/système V" qui ne te concerne probablement
pas,
a.2- la solution Windows,
oui sur windows et également portable sur *nix actuelsa.3- et la solution .so/SVR4 utilisée avec les *nix actuels),
Puis-je avoir l'assurance que plusieurs instances de mon programme
en
cours d'exécution aient leur variable externe utilisée exclusivement
des autres par une bibliothèque dynamique unique en mémoire ?
Oui (cf. supra, cas b-1). Mais ce n'est pas automatique (en
général)... De plus, au niveau des performances il y a un coût.
arhh... oui mais pas automatique (en général) ...hahaha
Comment puis-je le savoir sans tester ?
La solution que j'ai retenu pour l'instant est :
<couic>
Mais je ne sais pas si errbuff est unique pour chaque programme qui y
accède ou bien partagée par tout les programmes.
Comment obtenir les deux possibilités?