Thread: multiple return points

Hello

I was just wandering, if i have code like this.....

int main ()
{
/*declarations*/

if(xxx)
return 1;
else
p++


if (lllll)
return 0;
else
p++;


./ *similar coding to above */
.
.
.
.
retun 1;

}


Is that good programming practice? Or is there a way of not having multiple return points?

thanks

I think they generally teach in school that multiple returns are bad. However, sometimes they do fit the occasion. There are a lot of different ways to do things. Do you have something specific in mind that you're trying to write? I'll help you.
-kris

Well Kris i've done my program already but another person just advised me that i had to many multipl return points in my code.

At this point in time your help is not required but thanks for the offer anyway

cheers

but say the i had multiple return points in a function other than main that returns 1 or 0, is it good to have lots of these? Are there any other options for implementing these in different sorts of loops?

I agree with Shadow. It sounds like you're working on something
though. If you want to post what you're working on, we can tell
you if there's a better way
-kris

I personally find multiple returns pretty useful, as they let you quit loops easily and quickly, although i know it's not a good practice.

Another approach is to use a variable as the return value, change the return value as the function progress, then return the 'return value' whatever it is. Eg:

Code:

int retVal = 1; /* assume failure */

if ( num == 1 ) {
   num = 2;
   retVal = 0;
}

return retVal;

Originally posted by Nutshell
I personally find multiple returns pretty useful, as they let you quit loops easily and quickly, although i know it's not a good practice.

I also like using them, it seems to help shorten your code. I admit, I don't know what the academics say about using multiple returns.

In the ideal situation, one would return a value at the end of the function which tells how the function has finished. Avoiding the use of many multiple returns and avoiding large complex functions would lead to implementing many relative small functions which return a value. Depending on that value one would go further or not. So function-structures like these appear:

Code:

retval = function_a ();
retval &= function_b ();

if (retval == TRUE)
{
    retval = function_c ();

    if (retval == TRUE)
    {
        retval = function_d ();
        retval &= function_e ();

        if (retval == TRUE)
        {
            retval = function_d ();
        }
    }    
}

To avoid function structures like this, one could combine functions. For example:

Code:

retval = function_ab ();

if (retval == TRUE)
{
    retval = function_c ();

    if (retval == TRUE)
    {
        retval = function_de ();

        if (retval == TRUE)
        {
            retval = function_d ();
        }
    }    
}

But it is not always desirable to combine functions, since other functions may only want to use function_a() or function_b().

Having many small functions, leads to a lot of function calls. And when combining a lot of combined functions, this leads to a lot of duplicate code which is hard to maintain. Since when function_a() changes, you'll also have to change function_ab().

Therefore I think that multiple returns are okay when used with care.