Bonjour, Bonsoir chers amoureux de la programmation,

Ma question est la suivante:

Je programme en multi-fichiers avec bien-sur un seul fichier main.cpp (contenant le main principal sans arguments ie int main() {...} ). Cependant dans les autres fichiers j'ai mis des fonctions main (int main(  int argc, int *  argv [ ]  ) {...} ) dans lesquelles je récupère les chemins du fichier exécutable généré par le programme et le nombre de paramètres passés en arguments afin de faire quelques vérifications ...etc.

Quels sont les inconvénients d'après vous de cette méthode ie l'existence de plusieurs main même s'ils ont pas les même arguments ?

Existe-il une autre méthode pour récupérer le nombre d'arguments et le chemin de l’exécutable générée par le programme ?

Par avance je vous remercie respectueusement :))

Lu'!

MadiopLO1 a écrit:

Quels sont les inconvénients d'après vous de cette méthode ie l'existence de plusieurs main même s'ils ont pas les même arguments ?

Bah déjà le fait que l'existence de plusieurs points d'entrée empêchera l'édition des liens sur ton programme, donc tu ne pourras pas obtenir un exécutable.

MadiopLO1 a écrit:

Existe-il une autre méthode pour récupérer le nombre d'arguments et le chemin de l’exécutable générée par le programme ?

Il faudrait que tu expliques plus clairement ce que tu veux faire et pourquoi tu penses avoir besoin de plusieurs main pour ça.

Pas compris comment tu arrives a faire fonctionner ca. Tu ne peux avoir a priori qu'un seul point d'entrée dans ton programme.

Dans tous les cas, c'est pas légal : https://en.cppreference.com/w/cpp/language/main_function 

It cannot be predefined and cannot be overloaded

Pour des raisons de confidentialité, je ne peux joindre quelques bouts du code.

Dans le fichier main principal (main.cpp ) contenant le main sans arguments (int main () { corps } ), je fais appel à la commande "system" pour lancer des fichiers exécutables générés par le "Makefile" indispensables à mon programme.

Du coup je contrôle le nombre d'arguments et le chemin du fichier exe passés en paramètre à la commande "system" en insérant des fonctions main cette fois-ci avec des arguments main (int main(  int argc, int *  argv [ ]  ) { corps } ) dans les autres fichiers comme mentionné ci-dessus.

J'espère vous comprenez maintenant. Bien à vous en attendant,

Non.

Pourquoi ne pas juste implémenter la version "int main(int, char**)" et y gérer tous les cas de figures ???

Cela ne change rien a nos remarques. Si tu veux faire cela, il faut soit créer plusieurs programmes, soit avoir un seul main qui va dispatcher ensuite.

Le main sans argument, n'est qu'une facilité offerte pour ne pas avoir à effectuer de traitement dès lors que l'on sait par construction qu'il n'y aura jamais de paramètres sur la ligne de commande (ou plutôt qu'on n'en tiendra jamais compte). A partir du moment où on sait que l'on va potentiellement utiliser la ligne de commande (c'est à dire quasiment toujours en fait), il faut privilégier la forme avec des arguments. Si la ligne de commande ne comporte pas de paramètres, argc vaut 1, et argv ne contient qu'un seul pointeur qui pointe sur une chaîne de caractère contenant le nom de l'exécutable.

bacelar a écrit:

Non.

Pourquoi ne pas juste implémenter la version "int main(int, char**)" et y gérer tous les cas de figures ???

Si je le fais, cela me fera des milliers de lignes de commandes dans le seul main qui gérera tous les cas de figure. Raison pour laquelle je mets les autres dans les autres fichiers.

gbdivers a écrit:

Cela ne change rien a nos remarques. Si tu veux faire cela, il faut soit créer plusieurs programmes, soit avoir un seul main qui va dispatcher ensuite.

Je pense que si je mets tout dans un seul main, le corps de ce dernier va être kilométrique et lourd. Ce que je pense serait de changer les appellations et puis d'essayer de récupérer peut-être les chemins et le nombre d'arguments d'une autre manière.

-
Edité par madj_rek 24 mars 2019 à 16:00:39

Et les dieux inventèrent le concept de fonction, le principe de responsabilité unique et la factorisation...

-
Edité par int21h 25 mars 2019 à 8:07:32

MadiopLO1 a écrit:

Si je le fais, cela me fera des milliers de lignes de commandes dans le seul main qui gérera tous les cas de figure. Raison pour laquelle je mets les autres dans les autres fichiers.

Je pense que si je mets tout dans un seul main, le corps de ce dernier va être kilométrique et lourd. Ce que je pense serait de changer les appellations et puis d'essayer de récupérer peut-être les chemins et le nombre d'arguments d'une autre manière.

-
Edité par MadiopLO1 il y a environ 16 heures

Sérieusement, tu devrais commencer par les bases de la programmation avant de te lancer dans des trucs qui te semblent nécessiter des milliers de lignes.

Il est difficile de comprendre ce que tu veux. Si tu veux lancer plusieurs fonctions avec les mêmes paramètres que le main, tu peux faire ça

int main(int argc, char argv **) {
   module1_main(argc, argv);
   module2_main(argc, argv);
   module3_main(argc, argv);
   ...
}

avec pour chaque module une fonction qui sert de point d'entree

int module69_main(int argc, char **argv) {
   ...
}

-
Edité par michelbillaud 25 mars 2019 à 8:36:58

michelbillaud a écrit:

MadiopLO1 a écrit:

Si je le fais, cela me fera des milliers de lignes de commandes dans le seul main qui gérera tous les cas de figure. Raison pour laquelle je mets les autres dans les autres fichiers.

Je pense que si je mets tout dans un seul main, le corps de ce dernier va être kilométrique et lourd. Ce que je pense serait de changer les appellations et puis d'essayer de récupérer peut-être les chemins et le nombre d'arguments d'une autre manière.

-
Edité par MadiopLO1 il y a environ 16 heures

Sérieusement, tu devrais commencer par les bases de la programmation avant de te lancer dans des trucs qui te semblent nécessiter des milliers de lignes.

Il est difficile de comprendre ce que tu veux. Si tu veux lancer plusieurs fonctions avec les mêmes paramètres que le main, tu peux faire ça

int main(int argc, char argv **) {
   module1_main(argc, argv);
   module2_main(argc, argv);
   module3_main(argc, argv);
   ...
}

avec pour chaque module une fonction qui sert de point d'entree

int module69_main(int argc, char **argv) {
   ...
}

-
Edité par michelbillaud hier à 8:36

Relis bien mes posts svp , vous avez pas l'air bien comprendre ce que je dis; Je programme en multi fichiers avec de .h et des .cpp (module en quelque sorte)

-
Edité par madj_rek 26 mars 2019 à 14:45:56

Dans tes posts, tu n'expliques rien du tout de ce que tu fais et veux faire. Donc au risque de me répéter :

Ksass`Peuk a écrit:

MadiopLO1 a écrit:

Existe-il une autre méthode pour récupérer le nombre d'arguments et le chemin de l’exécutable générée par le programme ?

Il faudrait que tu expliques plus clairement ce que tu veux faire et pourquoi tu penses avoir besoin de plusieurs main pour ça.

Parce que pour prendre un exemple simple :

$ cat a.cpp
int main(int argc, char* argv[]){

}
$ cat b.cpp
int main(int argc, char* argv[]){

}
$ gcc -o exec a.cpp b.cpp
/tmp/cciO2kXk.o : Dans la fonction « main » :
b.cpp:(.text+0x0) : définitions multiples de « main »
/tmp/ccri8PSB.o:a.cpp:(.text+0x0) : défini pour la première fois ici
collect2: error: ld returned 1 exit status

Non, on ne peut pas avoir deux fonctions main dans le même programme.

> Je programme en multi fichiers avec de .h et des .cpp (module en quelque sorte)

Et ???

>Relis bien mes posts svp ,

Relis bien nos réponses.

Un exécutable n'a qu'une fonction marquée comme point d'entré de l'exécutable.

Le compilateur, il est bien obligé de trouver dans tout ce bordel de cpp, ce point d'entré. Il peut s'appeler comme il veut : "main" ou "mamieFaitDuVelo", du moment que tu configures les options du compilateur pour qu'il le trouve, quelqy'en soit son nom ou sa signature.

Mais ne pas utiliser "main (int argc, char** argv)", c'est vraiment se faire chier pour rien (hormis l'usage de Framework qui fixent le nom et la signature du point d'entré comme "wmain" etc...).

De notre point de vue, t'as complètement merdé ta conception en ayant des bout de point d'entré dans différents cpp et tu cherches un bricolage pour réparer ta boulette.

Soit tu as légitimement besoin d'une initialisation répartie et donc il faut passer par le procédé montré par @michelbillaud, ou tu prends la peine de bien concevoir la partie initialisation de ton programme pour qu'il soit unique et avec une signature correcte.

MadiopLO1 a écrit:

Relis bien mes posts svp , vous avez pas l'air bien comprendre ce que je dis; Je programme en multi fichiers avec de .h et des .cpp (module en quelque sorte)

Comme on ne peut pas supposer que c'est que tu n'arrives pas à formuler ce que tu veux, on va supposer que c'est qu'on est tous idiots.

Mais on va faire un effort. Si on relit ta question

> dans les autres fichiers j'ai mis des fonctions main (int main(  int argc, int *  argv [ ]  ) {...} ) |...]ls sont les inconvénients d'après vous de cette méthode ie l'existence de plusieurs main même s'ils ont pas les même arguments ?

La réponse est quand même assez simple : l'inconvenient, c'est juste que ça ne marche pas.

"ça" = plusieurs fonctions qui ont le même nom. A moins qu'elles n'aient été déclarées static, mais dans ce cas ça va être dur de les appeler d'un module à l'autre.

-----------

Only under the supervision of an adult :

// a.c
#include <stdio.h>

void foo();

int main() {
  printf("I a main\n");
  foo();
};

// b.c
#include <stdio.h>

static int main() {
  printf("I'm a main too\n");
}

void foo() {
  main();
}

$ gcc a.c b.c
$ ./a.out 
I a main
I'm a main too

-
Edité par michelbillaud 26 mars 2019 à 16:54:16

Petite précision sur le code de @michelbillaud, ce n'est pas valide en C++ car la fonction main ne peut pas être déclarée static.

@MadiopLO1: juste une question, tu arrives à compiler ton projet avec plusieurs main ? Si oui, comment ?