int my_func(int x);

void my_func_2(int x);

Generally, when a function does not return a value, two specific conditions should be met: first, the function should have no useful information to pass back, and second, nothing can go wrong during its execution, at least nothing that the function can detect.

For example, the standard library srand() function reseeds the random number generator. srand() has no information to send back, (one uses rand() to actually get a random number.) There is also nothing to go wrong, so the function is written to return nothing. Thus the prototype in the include file math.h gives the return type as void:

void srand(unsigned seed);

• when the function called has information to pass back and
• when you need to know if something has gone wrong.

In addition to deciding whether to return a value, you must also decide how to use the returned value. There are six common cases:

• discard it
• assign it to a variable,
• use it in a formula without assignment,
• assign and use it within a conditional test,
• use the result in a conditional test without assigning it, and
• pass it as an argument to another function.

char ch;
/* idle until user presses a key */
printf("Press any key to continue....");
getch();

/* or wait for a response, then save it */
printf ("Please enter your menu selection: ");
ch = getch();

FILE *fp;
fp = fopen("MYFILE.DAT", "r");

But, if the file is not found fopen() will not create it (since we have told fopen() to open the file in the "r" (read) mode. When fopen() is unable to open the file, it returns a flag telling you it has failed. This flag is NULL (or 0). Since the C standard guarantees that no pointer will be zero, when you get a NULL back from fopen(), you know something is wrong.

To test for this result, use:

if (fp == NULL)
   printf("file not found\n");
else
   printf("file found\n");

double square(), sqrt();
double side_a, side_b, temp, hyp;
temp = square(side_a) +
square (side_b);
hyp = sqrt(temp);

FILE *fp;
if ((fp = fopen("MYFILE.DAT",
"r")) == NULL)
     printf("file not found\n");
     else
        printf ("file exists\n");

if (fp = fopen("MYFILE.DAT",
"r") == NULL)

if (fp = (fopen ("MYFILE. DAT",
"r") == NULL))

If fopen() failed, returning a NULL, then the evaluated condition is NULL == NULL, which evaluates to TRUE. On failure, TRUE (non-zero and probably 1) will be assigned to fp. Since 1 is non-zero, the overall if conditional also evaluates TRUE, and the program appears to work correctly, reporting a failure.

If the file is present and fopen() can successfully open it, fopen() returns a non-zero value (the pointer to the structure FILE). This non-zero is compared with NULL. The condition:

<some non-zero pointer value> ==
   NULL

Perhaps the most common use of function return values as function arguments is in conjunction with printf(). For example:

double i = 5;
printf("the square root of %3.1f is %3.1f\n", i,
sqrt(i));

Many libraries implement certain functions as macros. These code substitutions simplify and clarify code and also speed execution by eliminating a function call.

For example, to convert a character to upper case you need only make a range comparison or do a table lookup to determine whether the character is lower case. Lower case letters can be converted to the corresponding upper case code by decrementing the ASCII value as necessary. For example:

char ch;
(if ch >= 'a' && ch <= 'z' ? ch - ('a' - 'A') : ch);

#define toupper(x)  \
   (if x>='a' && x <= 'z' ?
      ch -  ('a' -  'A') : ch);

With this macro definition present,

ch = toupper(ch);

Your compiler's macro is probably more complex (and more efficient), but still hides the same pitfall for the uninitiated: the macro argument is substituted (and evaluated) in more than one place.

Consider the statement:

ch = toupper(getch());

(if getch()>='a' && getch() <= 'z' ?
   ch - ('a' -  'A') : ch);

ch = getch();
ch = toupper(ch);

You can gain additional economies of expression by combining directly returned function values in equations used as arguments to other functions.

For example, these two lines from the earlier hypotenuse example:

temp = square(side_a) + square(side_b);
hyp = sqrt(temp);

hyp = sqrt(square(side_a) + square(side_b));

However, don't blindly assume that all functions will or should return NULL upon failure. In some cases a NULL can't be used as the error flag. For example, sscanf() returns the number of fields assigned. Zero is clearly a valid response, distinctly different from an attempt to read beyond the end of the input string. When zero is a valid return value, consider using EOF (typically a -1) to indicate an error. To test for EOF and save the return value, one could write:

if ((counter = sscanf(fp, format_in_buff, &my_var)) !=EOF)...

if (sscanf(fp, format_in_buff, &my_var) != EOF)...

if (sscanf(fp, format_in_buff, &my_var))...

When multiple errors are possible and more information about the error is desired, a single value flag is usually still returned to indicate the failure. However, before returning, the function sets a global variable, such as errno, to a value specifying in detail the cause of the problem. The calling function still uses the returned value to test for an error. But it may refer to the global for more details, if you, as the programmer, so choose.