#include..
#patatit patata

#define TYPE 1 // OU bien 0 ( c'est la le problème :/ )

void ma_funtionc(void);

#include...

#if TYPE
\t void ma_functionc(void){
\t\t printf("SALUT !");
\t}
#else 
\t void ma_functionc(void){
\t\t printf("AUREVEOIR !");
\t}
#endif

 (sry pour les \t\t )

Ici ça marche clairement ! Si je veux dire bonjour a chaque fois que j'appelle ma_functionc() dans le programme, je met TYPE a 1 ou 0 pour aurevoir.

Cependant le problème c'est que je voudrais que la fonction soit défini en fonction d'une variable dans le main(en gros il s'agit de argv[1]).

La ça se corse, je voudrais un truc du style : dans le .c,

void init_Function(bool type){
    if(type){
      void ma_function(){
        printf("BONJOUR");
      }
    }
    else
      void ma_function(){
        printf("Aurevoir");
      }
    }
}

 avec init_Function(bool type) en plus  dans le .h et #define TYPE en moins.

Mais bon, si ça marchais je ne serai pas la ..

Alors certes, il y a d'autre solutions, mais il y a une contrainte majeure : INTERDICTION de rajouter un argument dans ma_function ;

Seul une variable à l'intérieur du main, devra décider s'il s'agit de la première déclaration ou de la seconde. PS : on peut très bien lier le main.c et log.c si ça peut aider, et créer un main.h

-
Edité par Golgoo 22 mars 2018 à 18:20:44

Hello,

C'est clairement chercher midi à 14 heures !

void init_Function(bool type){
    ma_function(type ? "Bonjour" : "Au revoir");
}

indeed Edgar.

Par contre t'appelle la fonction avec un argument là ; void ma_function( type ?):/ j'ai absolument besoin de ne pas en utiliser :/ ma_function(void) et de pouvoir définir 2 fonctions différentes avec le même nom selon ce qui est passé en argument à l'exécution du programme. Je sais c'est tirée par les cheveux mais on est en C, il y sûrement un moyen et j'en ai vraiment besoin

-
Edité par Golgoo 22 mars 2018 à 22:09:46

Les directives du préprocesseur (#if et compagnie) sont évaluées juste avant la compilation, donc bien avant l'exécution.

Si ta fonction ne peut absolument pas avoir d'argument (drôle de contrainte, mais bon), peut-être que tu pourrais t'en sortir en définissant comme variable globale ce qu'edgarjacobs a utilisé en argument ? Si j'ai bien compris le problème de départ, il s'agira de copier argv[1] dans une variable globale, et c'est cette variable globale qui sera utilisée dans la fonction.

Je viens de faire un truc rapide :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char type[16] ;   // variable globale

void fonction(void)
{
    printf("Type : %s\n", type) ;   // pour vérifier que la fonction
                                    // accède à la variable globale
}

int main(int argc, char* argv[])
{
    if (argc < 1) return EXIT_FAILURE ; // ou <= 1 ? À vérifier...
    strcpy(type, argv[1]) ;
    fonction() ;
    return EXIT_SUCCESS ;
}

Ici la fonction 'fonction' se contente d'afficher la variable globale, mais on peut en faire ce qu'on veut, par exemple utiliser la variable globale pour un test.

(Mais bon, drôle de contrainte...)

-
Edité par robun 23 mars 2018 à 1:03:06

Je vais juste rectifier ton truc rapide ! Pas besoin de strcpy et c'est bien argc <= 1 !

#include <stdio.h>
#include <stdlib.h>
 
char *type;   // variable globale
 
void fonction(void) {
    printf("Type : %s\n", type) ;   // pour vérifier que la fonction
                                    // accède à la variable globale
}
 
int main(int argc, char* argv[]) {
    if (argc != 2)
			return EXIT_FAILURE ;
		type = argv[1];
    fonction() ;
    return EXIT_SUCCESS ;
}

Re,-

C'est peut-être ceci que tu cherches:

#include <stdio.h>

void (*fct)(void);

void f1(void) {
	puts("f1");
}

void f2(void) {
	puts("f2");
}

int main(int argc,char *argv[]) {
	if(argc>1) {
		if(*argv[1]=='1')
			fct=f1;
		else
			fct=f2;    // defaut
		fct();
	}
	
	return(0);
}

-
Edité par edgarjacobs 23 mars 2018 à 13:19:18

Merci à vous les deux solutions règlent le problème, pointeur de fonction me parait plus proche de ce que je voulais qu'une variable globale, sujet résolut thx !!

P.S. : la contrainte c'était pour appeler la fonction à de nombreux endroits dans le programme et ne pas avoir a modifié chaque appel si on veux qu'elle s'exécute ou pas, mais le choisir ça part une seule fois ( En gros -debug ou -release dans les arguments ).

Pointeur de fonctions me parait mieux pour gérer les headers et includes . Merci a vous en tout cas