函数什么时候应该返回什么？

Question

I'm a bit confused about the return type of a function, specifically when to return what. If we have any arbitrary function, let's say min(x,y), which should return according to the if statements, what should I return outside of their scope, which is required by the function's declaration. I've learned that it is common to use "return 0" or "return 1" but I don't understand why that is, and why it can't just return either of the if's return statements.

// compute difference largest - smallest
int   diff(x, y)
{
   if (x > y)
    return x - y;
   if (y > x)
    return y - x;
   if (x == y)
    return 0;
   return 1;
}

Answer 1

• If X is bigger than Y , return XY (obvious)
• If Y is bigger than X , return YX (also obvious)
• If X and Y are equal , what do you think should be returned?
  If they're equal, both XY and YX are 0 , so it doesn't really matter, does it?

Your final clause could be written any of:

return x-y;
return y-x;
return 0; 

Because they two values are equal, they will ALL evaluate to 0 .

The important part is to make sure the contract of the function is maintained.
According to the comments, the function claims it will return the difference between the two values. So it should return the difference in all cases , whether the bigger value is X, Y, or they are equal.

The name of your function is extremely misleading. Because it is named min , it implies it will return the minimum value, not the difference. You should change the name of the function to something like diff or delta for clarity.

---

Ultimately, the simpler way to write the function would be:

// compute largest - smallest
int diff(int x, int y)
{
   if (x > y)
    return x - y;   // Handles X is bigger than Y
   else
    return y - x;   // Handles Y bigger than X, *or* X and Y are the same.
}

Finally, some very short versions that I would consider better.

int diff(int x, int y) { return x>y? x-y:y-x; }
int diff(int x, int y) { return abs(x-y);     }

Answer 2

The compiler needs to make sure that you return something. If you have returns inside of if statements, such as you have, how is the compiler going to tell if you have covered all cases?

Even if you do something like the code below, how is the compiler going to know that you will return in all circumstances? Because of that this code will throw an error:

int min(int x, int y)
{
    if (x > y)
        return x - y;
    if (y > x)
        return y - x;
    if (x==y)
        return 1;
}

How can you combat this? You can write another return at the end of the function, as you have. Now the compiler know that you will return a value no matter what happens.

However there are better ways to make sure that you will always return a value. For example, you can use an else statement as a catch-all:

int min(int x, int y)
{
    if (x > y)
        return x - y;
    if (y > x)
        return y - x;
    else
        return 1;
}

Because the else is guaranteed to catch all cases, the compiler is happy about it, and will not throw any errors.

Answer 3

For a function that's computing the difference between two values, you would only return 1 if the difference between those two values was 1, 0 if they were equal.

There's a school of programming that says it's better to have a single return at the end of the function, rather than multiple returns scattered throughout. Instead of returning the difference in each branch, compute and store that difference, and return it at the end of the function:

int diff( int x, int y );
{
  int delta = 0;

  if ( x >= y )
    delta = x - y;
  else 
    delta = y - x;

  return delta;
}

Like most programming rules, there are exceptions. There are times where you want to exit immediately if a certain condition isn't met. Knowing when which approach is the better one is a matter of experience.

Answer 4

The return type of the function is specified in the definition, int in your case. Actually you need to specify the type of input arguments ( x, y ) and then the type of the output is usually derived from their type - like 2/3 cases in your function and the last one is integer ( 0 ).

Remark: You also need to choose better name for the function.