Allez à la main() de fonction définie par l'utilisateur

J'ai 3 fonctions: my_fun1(), my_fun2(), et my_fun3().

main() appels my_fun1() qui appelle my_fun2(), qui à son tour appelle my_fun3().

Sur certains pré-condition définie dans my_fun3(), je voudrais que mon programme pour aller directement à la main() fonction à la ligne my_fun1() a été appelé.

Est-il possible d'aller directement à partir de my_fun3() à main(), ou dois-je ajouter des conditions à my_fun2() et my_fun1() pour y parvenir?

InformationsquelleAutor A-A | 2011-07-14

break c++function main

4

Bien, il y a un moyen de passer directement à un autre point dans le code à l'aide de longjmp/setjmp, mais je ne vais pas vous dire comment parce que c'est un terrible idée. À peu près aussi mauvaise qu'elle l'obtient. Donc, nous allons parler de bonnes solutions :-).

La façon la plus évidente est d'utiliser exceptions. Comme ceci:
```
int my_fun3() {
    throw 1; //could be any type...
}
int my_fun2() {
    my_fun3();
}

int my_fun1() {
    my_fun2();
}

int main() {
    try {
        my_fun1();
    } catch(int n) { //catch the same type you threw...
    }
}
```
Si vous ne voulez pas utiliser les exceptions, (qui peut être le cas, certains pourraient faire valoir que ce serait un abus des exceptions si le raison pour remonter à la main n'est pas "exceptionnel") le plus simple est de faire my_fun1, my_fun2, et my_fun3 valeurs de retour qui signifie "faire" disons un int où une valeur inférieure à 0 signifie "aller retour". Votre appel à la structure devrait ressembler à ceci:
```
int my_fun3() {
   //...
   if(some_condition) {
       return -1;
    }

    return 0;
}

int my_fun2() {
    //...
    int r = my_fun3();
    if(r < 0) {
        return r;
    }
    //...
    return 0;
}

int my_fun1() {
    //...
    int r = my_fun2();
    if(r < 0) {
        return r;
    }
    //...
    return 0;
}

int main() {
    my_fun1();
}
```
- Je Vous Remercie. Mon code est-ce (bool retour de chaque fonction), mais je voulais juste savoir si il y avait une façon plus directe. Mais comme la plupart d'entre vous l'a suggéré, l'autre façon est de lever une exception, je ne pense pas que je vais modifier mon code.
InformationsquelleAutor Evan Teran
3

Oui, il est possible par la levée d'une exception et attraper que dans main. Mais s'il vous plaît ne pas utiliser les exceptions, comme un général de contrôle de flux de mécanisme, ce n'est pas ce qu'ils sont pour.

Il y a aussi setjmp/longjmp, mais le code à l'aide leur est très difficile à suivre.

InformationsquelleAutor Fred Foo
3

Retour de toutes les fonctions ou à lancer et à attraper une exception (pas recommandé, à moins que la raison pour aller en haut de la pile est vraiment situation d'erreur)

InformationsquelleAutor Mike Mozhaev

Propre approche sans abuser des exceptions seraient

#define EXITCONDITION 42

void main ()
{
  ...
  myfunc1 ();
  ...
}

int myfunc1 ()
{
  ...
  if (myfunc2 () == EXITCONDITION) return EXITCONDITION;
  ...
}

int myfunc2 ()
{
  ...
  if (myfunc3 () == EXITCONDITION) return EXITCONDITION;
  ...
}

int myfunc3 ()
{
  ...
  if (somethingweirdhappens) retrun EXITCONDITION;
  ...
}

Remarque: si La condition n'est requise que si il y a le code suivant à l'appel.
#define, void main - avez-vous vraiment besoin d'enseigner à de mauvaises pratiques?

InformationsquelleAutor Hyperboreus

0

Il semble que vous avez peut-être allusion à un goto qui est mauvais.

Pas voir la structure de votre programme, vous pouvez envisager un retour valeur booléenne (par exemple, un drapeau) qui est vérifié lors de son retour de la fonction n ° 3, ce qui est vérifié dans le #2, qui la renvoie, vérifié dans le #1, puis retourne à main().

InformationsquelleAutor
0

Il est possible par la levée d'une exception, comme larsmans dit (bien que C++ seulement). Il est également possible via setjmp()/longjmp(), qui agit comme une sorte de croix-fonction goto.

Mais si c'est vraiment le design que vous voulez/besoin, alors il y a probablement quelque chose de mal avec votre conception. Avoir conditions dans my_fun1 et my_fun2 peut-être la "bonne" réponse ici, mais cela dépend de ce que vous faites, bien sûr. Si vous publiez un peu plus d'informations sur la raison pour laquelle vous voulez/besoin de ceci, nous pouvons être en mesure de mieux vous aider.

InformationsquelleAutor arke
0

Il suffit de mettre votre premier appel de fonction dans une boucle. C'est l'une des généralement reconnus méthodologies de programmation de toute façon.
```
main
    while running
        do stuff
```
De sorte que vous pouvez faire
```
bool running = false;

int main(int argc, char **argv)
{
    while(running)
        function1();
}

void function3()
{
    ...
    if(whatever)
    {
        running = true;
        return;
    }
    ...
}
```
Si vous avez besoin d'fonction1() et fonction2() pour annuler de faire quelque chose basé sur ce comportement, alors que votre situation soit est une erreur ou c'est un peu comme une erreur, donc lancer une exception serait une meilleure solution. Même si ce n'est pas une erreur, c'est toujours fondamentalement le même type de logique de contrôle.

Cependant, si c'est le non-contrôle des erreurs de flux de votre programme, vous pourriez vouloir regarder le plus de structure et de comprendre ce qui est à l'origine vous avez besoin de le faire de cette façon et essayer d'éviter quelle que soit la logique qui est à l'origine.

InformationsquelleAutor Loduwijk

Vous devez vous connecter pour publier un commentaire.