Discussion :

[mzjul]

Hola todos,

Comme vous l'avez sûrement déjà compris, je cherche à relancer mon programme à partir de mon code (si une condition n'est pas satisfaite).
Je ne trouve pas de "méthode" ou "d'appel à une fonction" déjà existante, je fais donc appel à vos connaissances.
En espérant avoir été clair dans ma demande !

Merci d'avance,
Bien cordialement

[LittleWhite]

Bonjour,

Vous pourriez rappeler manuellement la fonction main(), mais, je n'aime pas beaucoup cette méthode.
Par contre, pourquoi ne pas envisager un code comme :

Code :

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

1
2
3
4
5
6
7
8
9
10
int main()
{
    while (cond)
    {
        prog1();
    }
    prog2();
 
    return 0;
}

[mzjul]

Bonjour,
Tout d'abord, merci pour la réponse.
Cependant, j'ai déjà pensé à cette solution et j'ai peur de surcharger mon main sachant que je veux juste relancer mon programme.
Un appel au main permettrait au même moment de détruire la première instance ?

[LittleWhite]

Un appel au main ne détruira rien.
Note : généralement, on gardera le strict minimum dans le main : l'analyse des arguments et le lancement du "reste du programme"
Je propose une seconde version.

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
 
void prog1(bool& cond)
{
    // Exécution normale (vous faites le travail nécessaire)
    cond = false; // Provoquera l'arrêt total du programme (pas de redémarrage)
    return;
}
 
int main()
{
    bool cond=true;
    while (cond)
    {
        prog1(cond); // 
    }
 
    return 0;
}

Sinon, il faudra expliciter votre besoin.

[koala01]

Salut,

A vrai dire, il faut surtout savoir quand la condition doit être évaluée.

En effet, si la condition n'est évaluée qu'une seule fois en début du programme, une approche cohérente pourrait ressembler à ce que fait un "updater", par exemple
updater.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int update_to(int version){
    /* mise à jour des composant */
   return last_version; //renvoie le numéro de la version téléchargée
}
int main(){
    int current_version =/* on la récupère comme on veut, sans doute dans un fichier de conf*/;
    while(true){
        int server_version = /* on la récupère comme on veut, sans doute en passant par le réseau */;
        if(server_version >current_version){
            current_version = update_to(server_version)
        }
        exec("mainProgram.exe");
};

Et, d'un autre coté, on a le "program principal" qui lui, fonctionne de "manière classique", quitte à vérifier régulièrement si la condition pour qu'il puisse fonctionner est toujours valide, par exemple
mainProgram.cpp

Code :

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

1
2
3
4
5
6
int main(){
    while(conditon) {
        /* tout ce qui doit être fait tant que la conditon est remplie */
    }
    return 0; // on peut considérer (sauf autre complication) que le programme s'achève correctement
}

Car, il faut savoir que, même si on peut appeler une fonction de manière récursive, ce n'est jamais une bonne idée que d'appeler la fonction principale de la sorte (sauf erreur, il me semble même que la norme prévoie que cela occasionne un comportement indéfini), sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
//!!!! ATTENTION !!!! A NE SURTOUT PAS FAIRE !!!
int main(){
    while(condition){
        /* ... */
    }
   main();
return 0;
}

Maintenant, rien ne t'empêche de déléger la "boucle principale" de l'exécution à "autre chose", par exemple sous une forme proche de

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
class Application{
public:
    /* ... */
   void execute(){
       /* la vraie logique se trouve ici */
       while(conditon){
           /* ...*/
       }
   }
};
int main(){
    while(true){
        try(){
             Application app;
             app.execute();
        }catch(...){ //s'assure que l'on ne sortira pas du programme, même en cas d'exception non gérée
            // ne fait rien ou log le problème, au choix
        }
    }
}

A conditon de travailler correctement (et donc de tout mettre en oeuvre pour que Application::execute() et les fonctions qui sont appelée de manière directe ou indirecte n'occasionnent entre autres aucune fuite mémoire / libère correctement TOUTES les ressources dont elle a besoin), ton application ne s'arrêtera jamais réellement

[JolyLoic]

main est une fonction spéciale, que l'on n'a ni le droit de surcharger, ni d'appeler:

§2: This function shall not be overloaded.
§3: The function main shall not be used within a program

[koala01]

main est une fonction spéciale, que l'on n'a ni le droit de surcharger, ni d'appeler:

Il me semblait bien que la norme disait quelque chose du genre, mais j'avais la flegme d'aller vérifier moi-même

[mzjul]

Merci encore pour toutes ces réponses, ce que j'essaie de faire pour être plus précis, c'est d'évaluer l'entrée d'une valeur, si celle ci ne correspond à rien indiquer à l'utilisateur que c'est faux et le faire recommencer.

Voici une partie du code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
cout << "For an equation like : df/dt + u(df/dx)=0 : " << "\n";
cout << "Which scheme do you want ? 1 For Explicit UpWind, 2 For implicit Upwind : ";
cin >> Scheme;
 
if (C.test(Scheme) == true)
{
// la j’exécute mon programme
}
else 
{
//relancer le main pour redemander la valeur de mon "scheme"
}

Je cherche une astuce assez simple et légère car c'est quelque chose d'optionnel pour faciliter l'utilisation du logiciel.

[Bousk]

Tant que le programme n'a pas besoin de mettre à jour son propre exe:

Code :

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

1
2
3
4
5
6
7
bool g_exit = false;
int main() {
  while (!g_exit) {
    // programme, ouverture fenetre etc...
    // ne pas oublier de modifier g_exit pour que le programme quitte vraiment et ne recommence pas
  }
}

[mzjul]

Parfait ! Ce m'a permit de comprendre comment faire ce que je voulais ! Merci bien !

[bacelar]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
...
int main(){
    while(true){
        try(){
             Application app;
             app.execute();
        }catch(...){ //s'assure que l'on ne sortira pas du programme, même en cas d'exception non gérée
            // ne fait rien ou log le problème, au choix
        }
    }
}

Virez-moi ce "try()catch(...){..}" !!!!!

[koala01]

Virez-moi ce "try()catch(...){..}" !!!!!

Ben, si le souhait est vraiment que l'application ne s'arrête JAMAIS, le try()cat(...) fera l'affaire, en s'assurant que tout repartir dans un état "cohérent" (même s'il risque de ne pas y rester longtemps)

Mais, de manière générale, je considère que ce n'est pas à l'application de décider si elle doit effectivement rester active en permance, qu'elle finisse par s'arrêter sur une exception ou non...

Selon moi, la responsabilité doit incomber "à autre chose"

[Médinoc]

Mais, de manière générale, je considère que ce n'est pas à l'application de décider si elle doit effectivement rester active en permance, qu'elle finisse par s'arrêter sur une exception ou non...

Selon moi, la responsabilité doit incomber "à autre chose"

Ou au moins, l'application peut demander à être redémarrée en cas de crash...