Discussion :

[Mikediten]

Salut à tous,

Je me demandais comment faire une macro récursive en C.

J'ai pas mal cherché mais je n'ai pas trouvé d'exemple clair qui marchait.
Si quelqu'un pouvait me donner un exemple clair.

Est-il possible de faire des boucles en macro préprocesseur ? par exemple de générer x fois une ligne de code.

Merci d'avance

[salseropom]

Salut, tu peux faire ceci comme macro :

Code :

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

1
2
3
4
5
6
7
 
#define MAMACRO \
do{\
 
ici tu écris tout ton code et tu rajoute un "\" à la fin de chaque ligne
}\
while(0)

J'utilise quotidiennement 2 macros :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#define FREE(p) \  /* liberation de la memoire et remise a NULL du pointeur */
do{\
  free(p);\
  p = NULL;\
}\
while(0)
 
#define FCLOSE(fid) \ /* fermeture d'un fichier et remise a NULL du pointeur */
do{\
  fclose(fid); \
  fid = NULL; \
}\
while(0)

[Mikediten]

Oui, mais ce genre de macro va seulement remplacer l'appel de la macro par la boucle à la compilation.
Ce que je cherche à faire, c'est une boucle ou une macro récursive qui permettrait d'écrire x lignes de codes à la compilation.

Je voudrais que la boucle (ou la récursion) soit exécutée à la compilation.

Je sais que c'est possible mais je n'ai toujours pas trouvé d'exemple.

PS : J'ai conscience de la "non propreté" de ce genre de code, mais là n'est pas la question.

[orfix]

Je voudrais que la boucle (ou la récursion) soit exécutée à la compilation.

Cette phrase est un peu confuse.
écrire

Code :

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

1
2
3
4
5
puts("Hello");
puts("Hello");
puts("Hello");
puts("Hello");
puts("Hello");

Donnera le même résultat que:

Code :

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

1
2
3
unsigned i;
for(i=0; i<5; i++)
	puts("Hello");

tu pourrais donc tout simplement faire :

Code :

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

1
2
3
4
5
6
7
8
 
#define FOO(n) do{ \
size_t i;
for(i=0; i<n; i++)
{	/* Traitement */
	puts("Hello\n");
}
while(0)

Je sais que c'est possible mais je n'ai toujours pas trouvé d'exemple.

J'en doute, une macro du genre

Code :

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

1
2
 
#define MACRO puts("Hello"); MACRO

Donnera

Code :

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

1
2
 
puts("Hello"); MACRO

et non

Code :

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

1
2
 
puts("Hello");  puts("Hello");  puts("Hello");  puts("Hello"); ...

La récursion n'est donc pas possible et c'est tant mieux !

If the name of the macro being replaced is found during this scan of the replacement list
(not including the rest of the source file’s preprocessing tokens), it is not replaced.
Furthermore, if any nested replacements encounter the name of the macro being replaced,
it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
available for further replacement even if they are later (re)examined in contexts in which
that macro name preprocessing token would otherwise have been replaced.

[jeroman]

A ma connaissance, c'est pas possible.

C'est quoi qui est gênant avec une boucle classique ??? Car au final, ça revient au même. Que tu exécutes 5 fois une même instruction ou qu'une boucle la fasse exécuter 5 fois, je ne vois pas la différence, mis à part l'utilisation d'une variable supplémentaire (pour le compteur), d'instructions servant à gérer le test de la condition et le saut conditionnel.

Si c'est un soucis de simplification d'écriture, tu peux même feinter de cette façon par exemple :

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>
#include <stdlib.h>
 
#define LOOP(nombre) { int compteur=0; \
while (compteur<nombre) {
#define ENDLOOP \
compteur++; \
} }
 
int main(void)
{
 
    LOOP(10)
    printf("hello\n"); /* instruction à exécuter X fois */
    ENDLOOP
 
    return EXIT_SUCCESS;
}

EDIT : Mince, grilled... lol

[Mikediten]

Je me suis mal faire comprendre.

Quand je dis :

Je voudrais que la boucle (ou la récursion) soit exécutée à la compilation.

Je veux dire que les macros sont exécutées à la compilation, ce qui n'est pas le cas du code C (exemple : while, puts etc.) qui est exécuté à l'exécution du binaire.
Toutes les solutions que vous me proposez sont exécutées à l'exécution et non à la compilation.

Par exemple en C++, on peut faire des templates récursifs, tous les calculs se feront à la compilation.

Moi je voudrais faire une boucle (ou une récursion) qui génère des lignes de code (par exemple : puts("Hello"); 50 fois ). Mais que ces 50 lignes de code soient générées au moment de la compilation, pas à l'exécution par une simple boucle while.
Par exemple, si j'ai oublié de mettre Hello entre guillemets dans la boucle de ma macro, je voudrais avoir 50 erreurs de compilation.

[jeroman]

Je me suis mal faire comprendre.

Non, non. C'est très clair depuis le début.
Mais je crains qu'en C, ça ne soit pas possible. En tout cas, à ma connaissance. En outre, le C est beaucoup plus soft que le C++.

Mais que reproches-tu à la méthode de la boucle classique ? Au final, ça fera la même chose. Car quelle différence trouves-tu entre :
1) Ecrire 50 instructions similaires, et donc exécutées 50 fois;
2) Ecrire une seule instruction, mais bouclée 50 fois
??

Lors de l'exécution, ça fait la même chose, on n'y voit que du feu...

Par exemple, si j'ai oublié de mettre Hello entre guillemets dans la boucle de ma macro, je voudrais avoir 50 erreurs de compilation.

Je ne vois pas en quoi en quoi c'est mieux d'avoir 50 erreurs au lieu d'une. Dans tous les cas, il suffit d'une seule erreur pour que la compilation s'arrête.

Qu'est-ce que tu veux faire concrètement ?

[Mikediten]

Le point de départ de cette réflexion, c'était un défi, faire le plus grand nombre d'erreurs de compilation avec un code source en C de moins de 100 caractères.

J'avais donc pensé aux macros récursives qui "gonfleraient" mon code, en copiant x fois une ligne avec une erreur.

Enfin vous avez peut être d'autres idées pour y arriver.

PS : c'est stupide comme jeu, mais bon ça demande plus de réflexions que ça en a l'air. J'ai des amis qui arrivent à faire plus de 350 000 lignes d'erreurs de compilation, enfin je connais pas leurs méthodes, chacun expérimente la sienne.

[orfix]

...c'est stupide comme jeu...

Tu m'étonnes

...J'ai des amis qui arrivent à faire plus de 350 000...

C'est tout ? Voilà ce que tu peux faire pour avoir des erreurs à l'infini (testé sous gcc version 4.3.2 )

Code ouch.c :

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

1
2
3
/* en DEUX lignes */
#include "ouch.c"
#include "ouch.c"

je n'ai pas envie de griller mon processeur pour prouver quoi que ce soit, je te laisse donc compiler ce code et faire le compte