Discussion :

[salseropom]

Bonjour, dans mon prgm, j'aimerais faire qq macros. Lorsque je fais un malloc, mon code est le suivan :

Code :

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

1
2
3
4
5
6
7
 
T * p=malloc(N*sizeof(*p));
if(p==NULL)
{
  fprintf(stderr,"%s:%d : Error : malloc() failed\n",__FILE__,__LINE__);
  exit(EXIT_FAILURE);
}

d'où ma macro suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#define MEMERROR \
do\
{\
  fprintf(stderr,"%s:%d : Error : malloc() failed\n",__FILE__,__LINE__);\
  exit(EXIT_FAILURE);\
}\
while(0)
 
T * p=malloc(N*sizeof(*p));
if(p==NULL) MEMERROR;

Serait-il maintenant possible de faire une macro du genre

Code :

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

1
2
 
T * p=MALLOC(p,N);

où la macro MALLOC fait qqch du genre (mais ça ne marche pas...)

Code :

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

1
2
3
4
5
6
7
8
 
#define MALLOC(ptr,size)\
do\
{\
  malloc(size*sizeof(*ptr));\
  ifptr==NULL) MEMERROR;\
}\
while(0)

Bien sûr ceci ne marche pas...


A propos de free : plutôt que de faire à chaque fois

Code :

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

1
2
 
free(p); p=NULL;

puis-je faire

Code :

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

1
2
3
4
5
6
7
8
 
#define FREE(ptr)\
do\
{\
  free(ptr);\
  ptr=NULL;\
}\
while(0)

Enfin, à propos du fclose(), puis-je faire, au lieu de

Code :

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

1
2
 
fclose(pfile); pfile=NULL;

une macro comme :

Code :

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

1
2
3
4
5
6
7
8
 
#define FCLOSE(ptr)\
do\
{\
  fclose(ptr);\
  ptr=NULL;\
}\
while(0)

Pouvez-vous donc s'il vous plait me conseiller sur ces macros ? Est-il recommandé de faire autant de macros (elles sont courtes donc lisibles) ?

Merci d'avance

[Gruik]

Salut,

A moins de tricher, tu ne peux pas faire "retourner" quelquechose à une macro multi-instruction. Donc pas de

Code :

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

T * p=MALLOC(p,N);

Je suggererais de faire une fonction inline (ou pas..), mais comme tu as besoin de la ligne et le fichier en cours, il faudrait une macro qui appelle cette fonction et lui passe en paramètre la ligne et le fichier en cours

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#define MY_MALLOC(size) my_malloc(size, __FILE__, __LINE__)
 
static inline void * my_malloc(size_t size, const char * fname, int line) {
   void * ptr;
   ptr = malloc(size);
   if (ptr == NULL)
   {
      fprintf(stderr,"%s:%d : Error : malloc() failed\n",fname,line);
      exit(EXIT_FAILURE);
   }
   return ptr;
}

[salseropom]

Ah oui, c'est très malin. Je vais essayer ça dès demain au boulot.
Merci.

[BainE]

Bonjour,

une tite question en passant.

Pourquoi systématiquement un "do while( 0 )" autour de tes macros ?

[DaZumba]

Pourquoi systématiquement un "do while( 0 )" autour de tes macros ?

Voir la reponse de la FAQ C.

[BainE]

Oui effectivement.

Jamais eu ce probleme, je mets *toujours* des accolades aux if meme pour une seule instruction (ou meme pas du tout).

[DaZumba]

Jamais eu ce probleme, je mets *toujours* des accolades aux if meme pour une seule instruction (ou meme pas du tout).

C'est une bonne habitude, mais tu ne peux pas garantir que tu seras le seul utilisateur des macros que tu definis.

[BainE]

Oui ca par contre !
J imagine bien le debbugage de ca ! en plus si la maccro est definie en minuscule, il doit y avoir moyen de s arracher les poils de la tete

[Médinoc]

Le seul inconvénient que je connais au do { } while(0) est que ça déclenche le warning "condition constante" de Visual quand celui-ci est activé, et que Visual n'offre rien pour empêcher cela.

C'est pourquoi j'utilise systématiquement des fonctions inline ou des macros appelant une fonction inline.

[salseropom]

Re,
y aurait-il qqun qui sait répondre à mes questions ?
Je vais essayer ce que tu dis Medinoc

Merci.

[Thierry Chappuis]

Re,
y aurait-il qqun qui sait répondre à mes questions ?
Je vais essayer ce que tu dis Medinoc

Merci.

Pour les macros FREE et FCLOSE, je ferais comme suit:

Code :

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

1
2
3
/* ATTENTION: ces macros evaluent deux fois leur parametre */
#define FREE(p) ( (p) ), (p)=NULL)
#define FCLOSE(f) (fclose( (f) ), (f)= NULL)

En ce qui concerne les macros qui concernent les macros pour *alloc(), tout est dans le tutoriel sur l'allocation dynamique de mémoire de Romuald Perrot: http://rperrot.developpez.com/articl...ocationC/#L4.2.
Thierry

[DaZumba]

y aurait-il qqun qui sait répondre à mes questions ?

J'ai du mal a voir l'utilite de macros autour de malloc() et free(), pour etre honnete. Je n'aime pas du tout ton exit(EXIT_FAILURE) en cas d'echec de malloc(): donc, on abandonne tout, on ne libere pas la memoire precedemment allouee, on ne ferme pas les fichiers ouverts, ... Ok, l'OS fera surement cela pour toi, c'est donc plus un probleme de qualite d'implementation, mais je suis d'avis que, notamment dans un projet un peu complexe ou le traitement d'erreur est important (logfile, assurance de l'integrite des donnes input, ...), seul main() devrait avoir le droit de terminer le programme.

[salseropom]

J'ai du mal a voir l'utilite de macros autour de malloc() et free(), pour etre honnete. Je n'aime pas du tout ton exit(EXIT_FAILURE) en cas d'echec de malloc(): donc, on abandonne tout, on ne libere pas la memoire precedemment allouee, on ne ferme pas les fichiers ouverts, ... Ok, l'OS fera surement cela pour toi, c'est donc plus un probleme de qualite d'implementation, mais je suis d'avis que, notamment dans un projet un peu complexe ou le traitement d'erreur est important (logfile, assurance de l'integrite des donnes input, ...), seul main() devrait avoir le droit de terminer le programme.

Salut, oui je comprends bien ce que tu dis. Pour ma part, dans mon travail, je fais des programmes pour résoudre des équations (je code des solveurs). Donc, s'il y a une erreur de mémoire, je ne pense pas que ce soit bien grave de stopper brutalement l'exécution.

En revanche, pour des applications commerciales, ce doit être tout autre chose.

[salseropom]

Salut,

A moins de tricher, tu ne peux pas faire "retourner" quelquechose à une macro multi-instruction. Donc pas de

Code :

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

T * p=MALLOC(p,N);

Je suggererais de faire une fonction inline (ou pas..), mais comme tu as besoin de la ligne et le fichier en cours, il faudrait une macro qui appelle cette fonction et lui passe en paramètre la ligne et le fichier en cours

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#define MY_MALLOC(size) my_malloc(size, __FILE__, __LINE__)
 
static inline void * my_malloc(size_t size, const char * fname, int line) {
   void * ptr;
   ptr = malloc(size);
   if (ptr == NULL)
   {
      fprintf(stderr,"%s:%d : Error : malloc() failed\n",fname,line);
      exit(EXIT_FAILURE);
   }
   return ptr;
}

Salut, j'ai modifé ta macro comme suit (et ça marche très bien)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#define MY_MALLOC(size) my_malloc(size)
 
inline void * my_malloc(size_t size) {
   void * ptr = malloc(size);
   if (ptr == NULL)
   {
      fprintf(stderr,"%s:%d : Error : malloc() failed\n",__FILE__,__LINE__);
      exit(EXIT_FAILURE);
   }
   return ptr;
}

Merci.

[Gruik]

Alors tu n'as pas besoin de la macro

Sinon, es tu sur que c'est le bon fichier et la bonne ligne qui sont utilisées?

A part ça, seul probleme que je vois avec les inline c'est que ça te pourrit un fichier d'en-tete. Rien que pour ça je serais tenté de faire une fonction classique dans un module commun au projet

[Thierry Chappuis]

Alors tu n'as pas besoin de la macro

Sinon, es tu sur que c'est le bon fichier et la bonne ligne qui sont utilisées?

A part ça, seul probleme que je vois avec les inline c'est que ça te pourrit un fichier d'en-tete. Rien que pour ça je serais tenté de faire une fonction classique dans un module commun au projet

Tu peux peut-être imaginer quelque chose comme cela:

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
#if defined(__STDC_VERSION__) && __STDC_VERSION__ <= 199901L
#  define INLINE inline
#else
#  define INLINE static
#endif
 
#define MY_MALLOC(size) my_malloc(size, __FILE__, __LINE__)
 
INLINE void * my_malloc(size_t size, const char * fname, int line) {
   void * ptr;
   ptr = malloc(size);
   if (ptr == NULL)
   {
      fprintf(stderr,"%s:%d : Error : malloc() failed\n",fname,line);
      exit(EXIT_FAILURE);
   }
   return ptr;
}

Certains compilateurs optimisent de manière à utiliser une fonction statique comme une fonction inline.

Thierry

[Thierry Chappuis]

Salut, j'ai modifé ta macro comme suit (et ça marche très bien)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#define MY_MALLOC(size) my_malloc(size)
 
inline void * my_malloc(size_t size) {
   void * ptr = malloc(size);
   if (ptr == NULL)
   {
      fprintf(stderr,"%s:%d : Error : malloc() failed\n",__FILE__,__LINE__);
      exit(EXIT_FAILURE);
   }
   return ptr;
}

Merci.

Le problème avec ton code, comparé à celui de Gruik, est que __FILE__ et __LINE__ correspondent respectivement au nom du fichier d'en-tête et à la ligne où l'appel à fprintf() est effectué. Avec la version de Gruik, __FILE__ correspond au fichier de la fonction appelante et __LINE__ à la ligne où l'appel est effectué dans ce fichier.

Thierry

[salseropom]

Le problème avec ton code, comparé à celui de Gruik, est que __FILE__ et __LINE__ correspondent respectivement au nom du fichier d'en-tête et à la ligne où l'appel à fprintf() est effectué. Avec la version de Gruik, __FILE__ correspond au fichier de la fonction appelante et __LINE__ à la ligne où l'appel est effectué dans ce fichier.

Thierry

Ah OK, je n'avais pas fait le test. Merci. Je vais donc reprendre la 1e version de cette macro.