Thread: Good examples of using goto and continue

In my c programming book that I'm currently reading, the author said that both goto and continue are both rarely used in any program and should be avoided whenever possible and that there are some exceptions where it is preferable to use these keywords(or any other keyword that changes state like break, return, etc). What would be an instance where it would make to sense to use goto or continue and not have it mess up your program(especially goto)?

Originally Posted by deathslice

both goto and continue are both rarely used and should be avoid whenever possible and that there are some exceptions where it is preferable to use these keywords. What would be an instance where it would make to sense to use goto or continue and not have it mess up your program(especially goto)?

Whether they are actually preferable to alternatives is debatable, but there are a few legitimate situations, e.g., for goto:

• Instead of repeating cleanup code or moving it to a separate helper function, one could place the cleanup code with a label towards the end of the function then use goto as part of error handling.
• Break out of nested loops, though it may or may not be better than simply making better use of loop conditions, e.g., with a flag.

For continue, perhaps one could use it similiarly to how one might return early from a function say for error handling, except that it goes to the next iteration early instead. On the other hand, perhaps this is a sign that the body of the loop should be moved to a function. If the body of the loop is small enough that moving it to a function is unnecessary complication, then perhaps merely negating the condition would suffice, i.e., instead of:

Code:

while (condition1)
{
    if (condition2)
    {
        continue;
    }
    foo();
}

one would write:

Code:

while (condition1)
{
    if (!condition2)
    {
        foo();
    }
}

Well here is an example of using goto

Code:

# include <stdio.h>

int main()
{
   float num,average,sum;
   int i,n;

   printf("Maximum no. of inputs: ");
   scanf("%d",&n);

  for(i=1;i<=n;++i)
  {
       printf("Enter n%d: ",i);
       scanf("%f",&num);

       if(num<0.0)
       goto jump;

       sum=sum+num;
  }

  jump:
  average=sum/(i-1);       
  printf("Average: %.2f",average);

  return 0;
}

and here is a slightly different version of it.

Code:

#include <stdio.h>

int main()
{
   float num, average, sum;   
   int i, n;

    printf("Maximum no. of inputs: ");
    scanf("%d",&n);


    for(i=1; i<=n; i++)
    {
        printf("Enter n%d: ",i);
        scanf("%f",&num);


        if(num<0.0)
        {
            average=sum/(i-1);
            printf("Average: %.2f",average);
            return 0;
        }
        else
            sum+=num;
    }


    average=sum/(i);
    printf("Average: %.2f",average);


    return 0;
}

Questions:

Is the second version any better than the first in terms of unnecessary code(is the program more compact and concise)?
is there any way that you would have modified the first version without use of keyword like return, break, goto, etc?

If you're processing a collection in a loop and want to skip some of the items, I prefer to use continue. For example, suppose I am processing a file line by line and want to ignore blank lines and comment lines. This is the correct way to write that:

Code:

while (fgets(ln, MAX, stdin)) {
    if (is_blank(ln)) continue;
    if (is_comment(ln)) continue;

    /* process line ... */
}

You can always emulate the 'continue' by rearranging things. But remember the whole reason you want to avoid break, continue, goto is to avoid convoluted code. If the above example is convoluted, it certainly is not due to using 'continue'. If you were the kind of person who is blindly following the "don't ever use continue" rule, then the above loop will probably end up looking like this instead:

Code:

while (fgets(ln, MAX, stdin)) {
    if (!is_blank(ln) && !is_comment(ln)) {
        /* process line ... */
    }
    // NB: please don't put any code here
}

This version is inferior to me because it adds an extra level of indentation for no reason. Plus in this version you really need to make sure you don't put any code right before the closing brace of the loop if you want to properly emulate 'continue'. In real code, people never add such a comment so when you review the code you have to carefully make sure that no surprise code gets added after your monster if block exits.

Originally Posted by c99tutorial

If you were the kind of person who is blindly following the "don't ever use continue" rule, then the above loop will probably end up looking like this instead:

Code:

while (fgets(ln, MAX, stdin)) {
    if (!is_blank(ln) && !is_comment(ln)) {
        /* process line ... */
    }
    // NB: please don't put any code here
}

This version is inferior to me because it adds an extra level of indentation for no reason. Plus in this version you really need to make sure you don't put any code right before the closing brace of the loop if you want to properly emulate 'continue'. In real code, people never add such a comment so when you review the code you have to carefully make sure that no surprise code gets added after your monster if block exits.

As I mentioned in post #2, I think that this is better than using continue, given that there are few conditions. I do not see the "extra" level of indentation as being for "no reason": it reminds the reader that there is a selection going on in the loop. The problem is that when there are too many conditions, using continue (or in a function, doing an early return: after all, with many conditions chances are moving the code to a separate function would be a good idea) is better because one would otherwise either end up with a hard to read long condition, or there would indeed be excessive nesting.