Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
Est-ce que ça dépend du type (entier, chaîne) de la constante ?
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
Est-ce que ça dépend du type (entier, chaîne) de la constante ?
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
Est-ce que ça dépend du type (entier, chaîne) de la constante ?
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Le 08/05/2009 11:56, mpg écrivit :Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
En 2009, le conseil normal, c'est de préférer const (lorsque c'est
possible).
Là où cela risque de poser le plus de difficultés, c'est pour les
constantes entières (genre le debug.h de ton exemple), et il y a de
grandes chances que tu sois obligé d'utiliser des valeurs du
pré-processeur (#define), surtout pour les dimensions de tableaux.
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Ce qui est quand même très laid de mon point de vue, mais moi je suis
complètement imbibé d'un style qui n'est plus moderne...
1º err_malloc n'est PAS une constante... il est parfaitement possible
d'écrire dans un autre coin du programme :
err_malloc = "tout va bien, billg aux commandes";
err_realloc = "mauvaise utilisation de strtol";
même si je ne pense pas que ce soit l'effet escompté...
2º techniquement ce code a un comportement indéfini (et d'ailleurs, un
compilateur normal va probablement râler) : la déclaration dans
erreurs.h annonce que la chaîne est modifiable, et le compilateur peut
prendre avantage de cette information, par exemple en supposant que la
chaîne est allouée dans l'espace réservé aux chaînes modifiables ; mais
la définition de erreurs.c va dans l'autre sens, et spécifie que les
contenus des chaînes ne sont pas modifiables, donc le même compilateur
devrait les alloués ailleurs, peut-être en mémoire en lecture seule (ROM)...
3º rien à l'utilisation ne permet de remarquer que err_malloc est une
chaîne constante ; c'est très différent d'utiliser ERR_MALLOC, ou mieux
encore MSGERR_MALLOC (ou MsgErr_malloc, si tu préfères un style plus
discret et qui ne permet pas de croire qu'il s'agisse d'une valeur du
pré-processeur).
Le 08/05/2009 11:56, mpg écrivit :
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
En 2009, le conseil normal, c'est de préférer const (lorsque c'est
possible).
Là où cela risque de poser le plus de difficultés, c'est pour les
constantes entières (genre le debug.h de ton exemple), et il y a de
grandes chances que tu sois obligé d'utiliser des valeurs du
pré-processeur (#define), surtout pour les dimensions de tableaux.
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Ce qui est quand même très laid de mon point de vue, mais moi je suis
complètement imbibé d'un style qui n'est plus moderne...
1º err_malloc n'est PAS une constante... il est parfaitement possible
d'écrire dans un autre coin du programme :
err_malloc = "tout va bien, billg aux commandes";
err_realloc = "mauvaise utilisation de strtol";
même si je ne pense pas que ce soit l'effet escompté...
2º techniquement ce code a un comportement indéfini (et d'ailleurs, un
compilateur normal va probablement râler) : la déclaration dans
erreurs.h annonce que la chaîne est modifiable, et le compilateur peut
prendre avantage de cette information, par exemple en supposant que la
chaîne est allouée dans l'espace réservé aux chaînes modifiables ; mais
la définition de erreurs.c va dans l'autre sens, et spécifie que les
contenus des chaînes ne sont pas modifiables, donc le même compilateur
devrait les alloués ailleurs, peut-être en mémoire en lecture seule (ROM)...
3º rien à l'utilisation ne permet de remarquer que err_malloc est une
chaîne constante ; c'est très différent d'utiliser ERR_MALLOC, ou mieux
encore MSGERR_MALLOC (ou MsgErr_malloc, si tu préfères un style plus
discret et qui ne permet pas de croire qu'il s'agisse d'une valeur du
pré-processeur).
Le 08/05/2009 11:56, mpg écrivit :Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
En 2009, le conseil normal, c'est de préférer const (lorsque c'est
possible).
Là où cela risque de poser le plus de difficultés, c'est pour les
constantes entières (genre le debug.h de ton exemple), et il y a de
grandes chances que tu sois obligé d'utiliser des valeurs du
pré-processeur (#define), surtout pour les dimensions de tableaux.
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Ce qui est quand même très laid de mon point de vue, mais moi je suis
complètement imbibé d'un style qui n'est plus moderne...
1º err_malloc n'est PAS une constante... il est parfaitement possible
d'écrire dans un autre coin du programme :
err_malloc = "tout va bien, billg aux commandes";
err_realloc = "mauvaise utilisation de strtol";
même si je ne pense pas que ce soit l'effet escompté...
2º techniquement ce code a un comportement indéfini (et d'ailleurs, un
compilateur normal va probablement râler) : la déclaration dans
erreurs.h annonce que la chaîne est modifiable, et le compilateur peut
prendre avantage de cette information, par exemple en supposant que la
chaîne est allouée dans l'espace réservé aux chaînes modifiables ; mais
la définition de erreurs.c va dans l'autre sens, et spécifie que les
contenus des chaînes ne sont pas modifiables, donc le même compilateur
devrait les alloués ailleurs, peut-être en mémoire en lecture seule (ROM)...
3º rien à l'utilisation ne permet de remarquer que err_malloc est une
chaîne constante ; c'est très différent d'utiliser ERR_MALLOC, ou mieux
encore MSGERR_MALLOC (ou MsgErr_malloc, si tu préfères un style plus
discret et qui ne permet pas de croire qu'il s'agisse d'une valeur du
pré-processeur).
Bonjour,
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
J'ai bien lu la réponse 5.4 de la
FAQ, et je vois bien pourquoi « ça n'a rien à voir », sauf que je
n'arrive pas à percevoir en quoi ça doit influencer le choix entre le s
deux dans la pratique.
Par exemple, il me semble qu'on voit couramment des définitions comme
/* debug.h */
#define KPSE_DEBUG_STAT 0 /* stat calls */
#define KPSE_DEBUG_HASH 1 /* hash lookups */
#define KPSE_DEBUG_FOPEN 2 /* fopen/fclose cal ls */
/* etc */
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Est-ce que ça dépend du type (entier, chaîne) de la constante ? Est -ce
que ça fait une différence technique ou bien est-ce une question de
style ?
Bonjour,
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
J'ai bien lu la réponse 5.4 de la
FAQ, et je vois bien pourquoi « ça n'a rien à voir », sauf que je
n'arrive pas à percevoir en quoi ça doit influencer le choix entre le s
deux dans la pratique.
Par exemple, il me semble qu'on voit couramment des définitions comme
/* debug.h */
#define KPSE_DEBUG_STAT 0 /* stat calls */
#define KPSE_DEBUG_HASH 1 /* hash lookups */
#define KPSE_DEBUG_FOPEN 2 /* fopen/fclose cal ls */
/* etc */
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Est-ce que ça dépend du type (entier, chaîne) de la constante ? Est -ce
que ça fait une différence technique ou bien est-ce une question de
style ?
Bonjour,
Comment choisir entre une définition de macro ou une définition de
variable avec le qualificateur const ?
J'ai bien lu la réponse 5.4 de la
FAQ, et je vois bien pourquoi « ça n'a rien à voir », sauf que je
n'arrive pas à percevoir en quoi ça doit influencer le choix entre le s
deux dans la pratique.
Par exemple, il me semble qu'on voit couramment des définitions comme
/* debug.h */
#define KPSE_DEBUG_STAT 0 /* stat calls */
#define KPSE_DEBUG_HASH 1 /* hash lookups */
#define KPSE_DEBUG_FOPEN 2 /* fopen/fclose cal ls */
/* etc */
J'ai aussi vu des exemples comme
/* erreurs.h */
extern char * err_malloc;
extern char * err_realloc;
/* etc */
/* erreur.c */
#include "erreurs.h"
const char * err_malloc = "erreur d'allocation mémoire";
const char * err_realloc = "erreur d'extension mémoire";
/* etc */
Est-ce que ça dépend du type (entier, chaîne) de la constante ? Est -ce
que ça fait une différence technique ou bien est-ce une question de
style ?