Constantes modifiables en C

J'aimerais connaître la stratégie des uns et des autres face à ce
petit problème.

faire une recopie ?

--
DINH V. Hoa,

"Ma tuxitude me beastifie" -- sunZ

En 366d80d80fkk5f4urst80u6t4qdee29q8g@4ax.com, Pierre Maurette va escriure:

Il est fréquent que des variables (de tous types) soient initialisées
par la lecture d'un fichier INI par exemple, voire un calcul ou
l'appel d'une fonction en début de programme.
Il peut arriver que ces "constantes" soient modifiables
"exceptionnellement" par un utilisateur identifié (on peut alors se
ramener au précédent, par clôture/initialisation).

C'est comme cela que je fais: on clôt la session en cours, on va dans le
module de modification (avec le flicage, empreintes, PGP certificats 509 et
tout et tout, enfin, on demande le mot de passe, quoi, en général avec
Entrée ça passe ;-)), les constantes sont modifiées, et on relance toute
l'appli.

Si un utilisateur se plaint que c'est trop lourd, je renvoie sur celui qui a
fait les specs fonctionnelles, car pour moi il y a un bogue fonctionnel: les
données "statiques" ne le sont pas en fait.

Évidemment, cela pose des problèmes de mises-à-jour ou de révision, comme on
veut, en multi utilisateurs concurrents.


OEQLC?

Antoine

In 'fr.comp.lang.c', Pierre Maurette <maurette.pierre@free.fr> wrote:

Bonjour,
Il est fréquent que des variables (de tous types) soient initialisées
par la lecture d'un fichier INI par exemple, voire un calcul ou
l'appel d'une fonction en début de programme.
Il peut arriver que ces "constantes" soient modifiables
"exceptionnellement" par un utilisateur identifié (on peut alors se
ramener au précédent, par clôture/initialisation).
Il me semble normal de conserver le statut const à ces variables. Pour
l'instant, j'utilise quelques cast, et ça roule.

J'aimerais connaître la stratégie des uns et des autres face à ce
petit problème.
--
Merci,

Pierre

#ifndef H_DATA
#define H_DATA

/* data.h */

/* structures */

typedef struct
{
int value;
}
data_s;

/* entry points */

int data_init (void);
int data_config (int value, char const *mdp);
data_s const *data_read_access (void);

#endif /* guard */


/* data.c */
#include "data.h"

#include <stdio.h>
#include <string.h>

/* private data */
static data_s *G_p_data;

/* entry points */
int data_init(void)
{
int err = 0;

static data_s S_data;

if (G_p_data == NULL)
{
G_p_data = &S_data;
}
else
{
puts ("Deja initialise... ");
err = 1;
}
return err;
}

int data_config (int value, char const *mdp)
{
int err = 1;

if (G_p_data != NULL)
{
/* ;-) */
if (strcmp (mdp, "L4v3r1t3_3st_41ll3urz") == 0)
{
G_p_data->value = value;
err = 0;
}
}
return err;
}

data_s const *data_read_access (void)
{
return G_p_data;
}

--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Emmanuel Delahaye <emdelYOURBRA@noos.fr> typa:

#ifndef H_DATA
#define H_DATA

/* data.h */

/* structures */

typedef struct
{
int value;
}
data_s;

/* entry points */

int data_init (void);
int data_config (int value, char const *mdp);
data_s const *data_read_access (void);

#endif /* guard */


/* data.c */
#include "data.h"

#include <stdio.h>
#include <string.h>

/* private data */
static data_s *G_p_data;

/* entry points */
int data_init(void)
{
int err = 0;

static data_s S_data;

if (G_p_data == NULL)
{
G_p_data = &S_data;
}
else
{
puts ("Deja initialise... ");
err = 1;
}
return err;
}

int data_config (int value, char const *mdp)
{
int err = 1;

if (G_p_data != NULL)
{
/* ;-) */
if (strcmp (mdp, "L4v3r1t3_3st_41ll3urz") == 0)
{
G_p_data->value = value;
err = 0;
}
}
return err;
}

data_s const *data_read_access (void)
{
return G_p_data;
}

Perfecto !
J'en étais pas loin, il m'a suffi de rendre const le pointeur renvoyé,
ce qui m'avait échappé :

/* dans prog.h */
enum { PREF_INI, PREF_LECT };
/* ... */
typedef struct
{
_uint8 BITS_DEF;
/* bla bla */
char* SESAME;
}
TPreferences;
typedef const TPreferences * PPreferences;
/* ... */
PPreferences Preferences(int Commande);

/* dans prog.c */

PPreferences Preferences(int Commande)
{
static TPreferences TP;
FILE * fPref = NULL;
if(Commande == PREF_INI)
{
/* bla bla */
}
return & TP;
}
--
Merci,
Pierre

"Antoine Leca" <root@localhost.gov> typa:

En 366d80d80fkk5f4urst80u6t4qdee29q8g@4ax.com, Pierre Maurette va escriure:

Il est fréquent que des variables (de tous types) soient initialisées
par la lecture d'un fichier INI par exemple, voire un calcul ou
l'appel d'une fonction en début de programme.
Il peut arriver que ces "constantes" soient modifiables
"exceptionnellement" par un utilisateur identifié (on peut alors se
ramener au précédent, par clôture/initialisation).

C'est comme cela que je fais: on clôt la session en cours, on va dans le
module de modification (avec le flicage, empreintes, PGP certificats 509 et
tout et tout, enfin, on demande le mot de passe, quoi, en général avec
Entrée ça passe ;-)), les constantes sont modifiées, et on relance toute
l'appli.

Si un utilisateur se plaint que c'est trop lourd, je renvoie sur celui qui a
fait les specs fonctionnelles, car pour moi il y a un bogue fonctionnel: les
données "statiques" ne le sont pas en fait.

Évidemment, cela pose des problèmes de mises-à-jour ou de révision, comme on
veut, en multi utilisateurs concurrents.


OEQLC?
Ça veut dire "Où est la question sur le langage C ?" ?

En fait, j'avais mal posé ma question. Le problème des utilisateurs
identifié n'est que marginal et ne me concerne pas.
Ce qui me chagrinait, c'était le cats des const.
--
Pierre