Discussion :

[n0mad]

Bonjour,

je viens de voir que les macros permettent de "factoriser" du code un peu comme les fonctions.

Aussi j'ai un programme ou j'ai énormément d'appels à malloc avec test de réussite et je souhaiterai savoir si je peux en faire une macro.

Code :

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

1
2
3
 
if( ( var = calloc(taille_variable, sizeof(type_variable) ) == NULL )
                return -1;

Enfaite je souhaite lorsque je déroule mon programme, qu'il alloue de la mémoire et retourne -1 en cas d'erreur. Si tout se passe bien, "il ne se passe rien" et le programme continue. La taille et le type de var changent (char, unsigned long int, etc).

Mon idée serait donc qqc du style :

Code :

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

1
2
3
4
 
#define allocation(a, b)
           if( ( var = calloc(a, sizeof(b) ) == NULL )
                     return -1;

J'y connais rien en macro donc deja : est-ce que c'est possible ? Si oui comment ? Sinon pensez vous que ce soit plus pertinent qu'une fonction ?


Est-ce la libération de cet espace mémoire sera identique : free(var) ? (dans la mesure ou c'est possible).

Merci de vos lumières =)

n0mad

[Obsidian]

Je pense que ce que tu cherches à faire en l'occurence est un fonction inline.

Méfiance toutefois : tel que tu as écrit ta macro, le « return -1 » provoquera la sortie de la fonction dans laquelle tu l'as invoquée, pas la sortie de la macro elle-même.

Cependant, si ton code est déjà écrit comme cela, tu peux effectivement mettre ça en macro pour raisons de lisibilité : sache juste que le précompilateur va remplacer toutes les macros qu'il rencontre par le code qui leur est associé, et ce n'est qu'après cette étape que le compilateur va commencer son travail. Ainsi, celui-ci ne saura pas si le code qu'il compile a été écrit en toutes lettres au sein de la fonction ou s'il s'agissait d'une macro qui a été développée.

[elmcherqui]

voila c'est pas tres sain comme code mais juste pour te depanner :
sa met

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
#include<stdio.h>/** puts **/
#include<stdlib.h>/**exit **/
 
 
#define alloue(a,b)  malloc(a*sizeof(b))
 
#define allocation(a,b,var)   if( (var = alloue(a,b)) == NULL  ) { \
                                    puts("allocation a echoue");\
                                    exit(-1);\
                                    }
 
 
int main(){
    int* p ;
    allocation(10000000000000000000000000000,double,p) /**pour etre sur qu'elle echoue**/
 
    return 0 ;
}

l'adresse allouee dans p

[Emmanuel Delahaye]

voila c'est pas tres sain comme code mais juste pour te depanner :

Comportement indéfini. Il ne faut pas faire n'importe quoi...

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
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c:13: warning: function declaration isn't a prototype
C:\dev\hello\main.c:15:54: warning: integer constant is too large for its type
C:\dev\hello\main.c: In function `main':
C:\dev\hello\main.c:15: warning: integer constant is too large for "long" type
C:\dev\hello\main.c:15: warning: integer overflow in expression
C:\dev\hello\main.c:15: warning: large integer implicitly truncated to unsigned type
Output size is 19.21 KB
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 5 warnings

ceci fonctionne correctement :

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
19
20
21
22
23
24
25
 
#include <stdio.h>
#include <stdlib.h>
 
#define alloue(a, b) malloc (a * sizeof (b))
 
#define allocation(a, b, ptr)\
do\
{\
   if ((ptr = alloue ((a), b)) == NULL)\
   {\
      printf ("l'allocation a echoue en %s:%d\n", __FILE__, __LINE__);\
      exit (EXIT_FAILURE);\
   }\
}\
while (0)
 
int main (void)
{
   double *p;
   /**pour etre sur qu'elle echoue**/
   allocation (-1, double, p);
 
   return 0;
}

[elmcherqui]

merci -ed- pour la correction .
Cependant meme en activant tous les warning sur code::blocks je n'ai pas eu autant que les tiens comment sa se fait ? quelqu'un pourrais m'indiquer comment rendre mon compilateur plus attentif ?
(j'ai windows Xp )

non c'est bon c'est moi qui ne suis pas attentif en fin de compte . par contre si quelqu'un qui s'y connait en macro pourrais expliquer l'utilité du
do { }while(0) dans la macro je lui en serait reconnaissant . Merci.

[Emmanuel Delahaye]

non c'est bon c'est moi qui ne suis pas attentif en fin de compte . par contre si quelqu'un qui s'y connait en macro pourrais expliquer l'utilité du
do { }while(0) dans la macro je lui en serait reconnaissant . Merci.

Forcer l'usage de la ';' (que tu avais oubliée)

Pour les warnings :

http://emmanuel-delahaye.developpez....tm#cfg_compilo

Évidemment, pour les voir, ne pas se précipiter sur F9 (build and run), mais faire build ...

[pfeuh]

Salut,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#define alloue(a, b) malloc (a * sizeof (b))
 
#define allocation(a, b, ptr)\
do\
{\
   if ((ptr = alloue ((a), b)) == NULL)\
   {\
      printf ("l'allocation a echoue en %s:%d\n", __FILE__, __LINE__);\
      exit (EXIT_FAILURE);\
   }\
}\
while (0)

Au sujet de la factorisation, qui semble être la demande du PO, ne serait-il pas plus intéressant de transformer ta macro en véritable fonction?

Ok, je viens de voir l'intérêt de la macro. Je me suis encore cru en python, ou le type d'une variable passée à une fonction n'est pas figé. Ce qui ne fonctionne pas en C.


A+

Pfeuh

[Emmanuel Delahaye]

Au sujet de la factorisation, qui semble être la demande du PO, ne serait-il pas plus intéressant de transformer ta macro en véritable fonction?

Il faut au moins une macro pour que __FILE__ et __LINE__ aient un sens.

Ok, je viens de voir l'intérêt de la macro. Je me suis encore cru en python, ou le type d'une variable passée à une fonction n'est pas figé. Ce qui ne fonctionne pas en C.

Oui, autre problème.

[pfeuh]

Il faut au moins une macro pour que __FILE__ et __LINE__ aient un sens.

C'est ça qui est bien avec tes exemples, il y a toujours quelque chose à prendre. __FILE__ et __LINE__, je ne connaissais pas.