Any way to return to the top of main from a function

Hello everyone. Sorry if this is a stupid question.

Let's say that I have a program which consists of many different branches of functions. Is there any simple way to make a statement or set a condition to return to the top of main (essentially restarting the program) from a separate function without using a loop in main?

I read up on the goto statement but apparently this only works within the same function. I am looking for something similar that can hop across functions I suppose.

yea put the code you want in main in another function, and then just call that function in main once, then call recursively as many times as needed.

I see what you're driving at, but then won't I have to hop back through a couple functions anyway to return to the top of the new "main" function.

You don't want to be calling main() again. No!

Main calls a menu or driver function, and that has your loops, switch statements, and calls all the top level functions.

Those top level functions may have their own sub menu's and or directly call some second level functions, themselves.

But you never call main, again. Loop back, or forget it.

On another note, avoid using goto if you can. Because goto can jump all over the place, it's often considered bad practice to use it. It can cause messy code.

Is this what you want to do?
(Note, pseudo-C to clarify the problem, it won't compile)

Code:

---

int main()
{
label:
    func1();
}

func1()
{
  dostuff();
}

dostuff()
{
    choice = menu();
    if (choice == '9') goto label;
}

---

--
Mats

Why are we using goto matsp? It works, but since they are meant to be avoided wouldent a loop would be better:

Code:

---

int again()
{
    //if says yes then return 0
}

int main()
{
    // Do initailisation here   
    int done = 0;
    while(done == 0)
    {
          // Do stuff to loop over here
          done = again();
    }
    return 0;
}

---

I think mats was trying to ask if the sort of behaviour posted was what the OP wanted to achieve. I don't think mats was trying to tell the OP in any way to do it that way.

Yes, I was trying to understand what the original poster actually wants to achieve - not in any way suggesting the solution in the code.

--
Mats

Ok sure, I just re-read the op's post. tbh, I see no need to jump to the top of main from inside one of these functions. IMO A better structure would be that when the user wants to reset the program to break out of the inner function to main, which then loops back to the start.

Quote:

---

Originally Posted by mike_g

Ok sure, I just re-read the op's post. tbh, I see no need to jump to the top of main from inside one of these functions. IMO A better structure would be that when the user wants to reset the program to break out of the inner function to main, which then loops back to the start.

---

Sure, but before we can issue a right solution, we need to understand what the ACTUAL problem is - there are several different possibilities - but the right one for one scenario isn't the right one for another one.

--
Mats

I think the op wants to break out of functions several layers deep, which would require code to break out in all the calling functions. Something like:

Code:

---

int IsEnd()
{
    // if is end return 1
}

int MoreStuff()
{
    if( IsEnd() ) return 1;
    // Do stuff
    return 0;
}

int DoStuff()
{
    if( MoreStuff() ) return 1;
    // Do stuff
    return 0;
}

int main()
{
    while(! done)
        DoStuff();
}

---

I would have thought they want to call main recursively.

Code:

---

void go(void)
{
    /* ... */

    go();

    return;
}


int main(void)
{
    go();

    return 0;
}

---

Well it's a guessing game at the moment.

Quote:

---

Originally Posted by zacs7

I would have thought they want to call main recursively.

Code:

---

void go(void)
{
    /* ... */

    go();

    return;
}


int main(void)
{
    go();

    return 0;
}

---

Well it's a guessing game at the moment.

---

That is the solution suggested in post #2, but that's not "essentially restarting the program", which is what post #1 mentions. It may of course just be that I'm reading too much into a not so clearly written quesiton...

--
Mats

If I've understood the problem correctly, there are basically two ways to "restart" the program. You can use recursion as zacs7 and Raigne suggested; but this means that you might end up with a stack overflow if you do it too often. It also uses lots of unnecessary memory and so on. In general, this is the last way I'd do this.

What I would do is what mike_g suggested: use return values to communicate up the stack that you want to restart the program. It's not too difficult, actually, unless you're already using return values extensively; in that case, you might want to set a flag instead.

Another alternative that hasn't been mentioned is to use longjmp(), a sort of cross-function goto -- but there's a reason it hasn't been mentioned, and that is because this is not a good function to use at all!

Try using return values and see how it goes.

Quote:

---

Originally Posted by dwks

Another alternative that hasn't been mentioned is to use longjmp(), a sort of cross-function goto -- but there's a reason it hasn't been mentioned, and that is because this is not a good function to use at all!

---

Yes -- using longjmp() would require you to first clean up all allocated resources (otherwise you'd leak a bunch of stuff on every "restart"). The logic involved in doing this is going to be basically the same logic as returning normally back up the call stack in the first place.

Another silly method would be to re-exec() yourself. Actually, depending on the context (which is still completely unclear), that might not be such a bad option.

I'd still like to hear what the original poster would want to do - and yes, I had thought of longjmp, but as you mention, it's bad in the case of allocated memory.

--
Mats

Sorry for my absence. I have had a lot of other things going on besides programming.

For some reason I thought that converting my main function to a separate function and calling a recursion when necessary would be too much work and require too much hacking at my original code. After thinking about it more I don't see why this would be the case anymore. It should be quite simple actually. I will give that a try and get back to you guys.