Discussion :

[trobin]

Bonjour,

Je reprends un programme avec comme particularité d'avoir dans un header utilisé partout des "sections" offrant des fonctionnalités particulières. Parmi la dizaine présentes, tous ne sont pas utilisées dans le programme. Dès lors dans le header en question, certaines sections ont été commentées.
Dans certains fonctions on peut avoir des structures directement liées à ces sections. Je me pose donc la question suivante :

Puis-je utilisé un #ifdef directement dans ma fonction comme je le fais dans le code sans que cela ne pose de soucis ?

illustration avec un exemple :
dans mon header

Code :

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

1
2
#define	SECTION_IMAGE	1 // Index section image
#define	SECTION_GRAPH        2 //Index section Graphique

dans une fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
//-----------------------------------------------
// SUBROUTINE BODY
//-----------------------------------------------
void _traifunc1( long   info  	// Flag d'information
	          , long   pointer 	// Pointeur
#ifdef SEC_GRAPH
                 , struct graph_abs  abs  // structure graph en données absolues
#endif
	          , long * status 	// Status d'execution
	       )
{
	long     i;	// counter

[Invité(e)]

Bonjour,

Puis-je utiliser un #ifdef directement dans ma fonction comme je le fais dans le code sans que cela ne pose de soucis ?

Hum, techniquement, je ne vois pas la différence entre fonction et code.

Mais oui, on peut utiliser les #ifdef et des #define à peu-près n'importe où dans du code.
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
#include <stdio.h>
void dire_bonjour(void)
{
#ifdef WIN32
    printf("Bonjour depuis windows\n");
#else 
    printf("Bonjour depuis ailleurs\n");
#endif
}
 
int main(void) 
{
    dire_bonjour();
    return 0;
}

Mais il faut savoir que les directives préprocesseur (toutes celles qui commencent par #) ne seront évaluées qu'un fois par le préprocesseur avant la compilation proprement dite.
Ainsi, le code suivant :

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
#include <stdio.h>
 
void foo(void)
{
#ifdef FOO
    printf("FOO existe\n");
#else
    printf("FOO n'existe pas\n");
#endif
 
}
 
int main(void)
{
    foo();
#define FOO
    foo();
    return 0;
}

donne

Code :

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

1
2
FOO n'existe pas
FOO n'existe pas

[trobin]

merci mabu de ta réponse rapide.

je partage cet avis sur le fait qu'il n'y ait pas de différence à proprement dite entre code et fonction.

j'ai juste des craintes du résultat et surtout je ne souhaite pas que cela plante

[Invité(e)]

je partage cet avis sur le fait qu'il n'y ait pas de différence à proprement dite entre code et fonction.
j'ai juste des craintes du résultat et surtout je ne souhaite pas que cela plante

Ok, en fait, tu veux pouvoir modifier le prototype de la fonction par #define.

Le problème est un peu différent.

Il faut s'assurer que lorsque le prototype change dans la déclaration, il change aussi dans la définition de la fonction.

Pour être sur d'éviter les soucis, il faudrait recompiler la définition de la fonction et tous les appels à chaque changement de macro pouvant modifier le prototype. (un Makefile bien fait peut suffire).

Pour se simplifier la vie, on peut aussi choisir de modifier légèrement le nom de la fonction en fonction des macro définies ou non. (Comme le prototype change, on devra de toute façon modifier l'appel)

[trobin]

Merci, et oui, la seconde proposition me semble plus sûre. Toutefois, j'avais bien pris en compte le fait qu'il fallait s'attaquer à la déclaration ainsi qu'à la définition.

Pour le moment, j'ai opté pour la prudence et je ne vais pas toucher à mes fonctions, et me focaliser sur les sections qui ne modifient en rien la déclaration et la définition des fonctions, mais juste ce qu'elles contiennent.