What is the use of break and exit statements in c?

Answer 1

A break is a jump statement that allows code to exit a statement block without processing the remaining instructions in that statement block. Execution continues with the statement following the statement block.

Jump statements (the break, return, continue and goto keywords) are typically used in conjunction with a conditional expression, to allow execution to branch to another section of code within the same function whenever the expression is true. Function calls do a similar type of thing, branching off to other sections of code, but execution always returns to the point the call was made. Jump statements do not.

However, jump statements are also used in conjunction with switch statements. If a case label does not have a jump statement before the next case label is encountered, execution will fall through to the next label (just as as if that label did not exist). Sometimes this may be the intention but, in most cases, once a specific case has been handled, execution is normally passed to the statement immediately following the switch block, in which case a break is required (return and goto can also be used to exit a case label, but not continue). The final case (or default case) does not require a break if execution is expected to fall through to the statement following the switch statement.

With regards to the other jump statements:

The continue statement is used in loops, to start a new loop without executing any remaining command in the loop. In do..while() loops, execution is passed to the while(condition) expression.

The goto statement jumps to a given label, which must be present somewhere within the same function. A label is a user-defined name followed by a colon, marking the point in the function the goto will jump to.

The return statement exits a function altogether, returning control back to the calling function.

Answer 2

In order to return from a function, C provides the returnkeyword, which can be used anywhere in a function for an immediate exit of that function.

For void functions, which do not return values, return by itself is sufficient to exit the function. I.e.:

void printhello(int numtimes)

{

int count;

if (numtimes<1) {

printf("Cannot print hello!\n");

return;

}

for (count=0; count

}

For functions returning a value, specify a value or variable of the return type. Example:

char *stringcat(char *str1, char *str2)

{

char *returnstr;

if ((str1==NULL)(str2==NULL) return NULL;

returnstr=(char*)malloc(strlen(str1)+strlen(str2)+1);

*returnstr=0;

strcat(returnstr, str1);

strcat(returnstr, str2);

return returnstr;

}

If you wish to stop the program immediately, use exit(n), where n is an integer value. This will return n as an exit code which is returned to the system calling the program. (-1 is a good generic value for errors, 0 for success.) I.e.:

void doprint(int numparam, char **paramlist)

{

int count;

if (argc<1) {

printf("Specify one or more parameters.\n");

exit(-1);

}

for (count=0; count

printf("#%d:%s\n", count, argv[count]);

}

int main(int argc, char **argv)

{

doprint(argc, char **argv);

return 0;

}

Always be sure you've closed files that are open and freed memory you no longer need prior to using return (and, for sake of habit, exit()).

Answer 3

The break statement is used to terminate the nearest enclosing do, for, switch or while statement. Control passes immediately to the statement that immediately follows that enclosing statement.

The exit() function terminates the program at the point of the call and returns the given value to the host environment. It effectively does the same thing as a return statement in the main function would:

#include<stdlib.h>

#include<stdio.h>

int main (void) {

FILE* pf;

pf = fopen ("file.txt","r");

if (pf == NULL) {

printf ("Error opening file\n");

exit (EXIT_FAILURE); /* same as calling return -1; */

} else {

/* use file */

fclose (pf);

}

return 0; /* same as calling exit (EXIT_SUCCESS); */

}

Note that calling exit() from any other function besides main should be used cautiously as this will effectively prevent any return to the main function (exit() does not and cannot return to its caller). However, any functions registered with atexit will be invoked by exit(), all open streams will be closed (and flushed if buffered) and all files created with tmpfile will be removed before control passes to the host environment. If any other clean up is required, you must manually invoke that clean up prior to calling exit().