How do you "break" out of a function?

Question

Given a function that returns a value, is it possible to exit the function given a certain condition without returning anything? If so, how can you accomplish this?

Example:

int getNumber ()
{ 
    . . . 
}

So say you are in this function. Is there a way to exit it without it doing anything?

Answer 1

Alternative of exceptions is return of status code:

SomeStatusCode YourFunc(int &returnValue)
{
    ...
    returnValue = SomeValue;
    return SomeStatusCode.Successful;
    ...
    return SomeStatusCode.Fail;
}

//in main func

   if(YourFunc(retValue)==SomeStatusCode.Successful)
   // work with retValue
   else
   // nothing to do, show error, etc.
</code>

Answer 2

You have two options: return something or throw.

int getNumber() 
{
    return 3;
}

int getNumber() 
{
    throw string("Some Var");
}

---

If you throw, you have to catch the type you threw.

int maint(int argc, char ** argc)
{
     try
     {
           getNumber();
     }
     catch(string std)
     {
          //Your code will execute here if you throw
     }
 }

Answer 3

You might get away with a return; with no return value. The compiler will warn, but may not error.

BUT, why on earth would you even consider this? What are you trying to achieve?

And what does the calling code look like? If it is int someVar = getNumber(); then the value of someVar is undefined (which is A Bad Thing).

It sounds to me like you want to return two pieces of information, one of which tells you if the other is valid.

Try something like

bool GetNumber(int * outputNumber)
{
   if ....
   {
      *outputNumber = ...;
      return true;
   }  
   else
   {
      return false; // contents of outputNumber are undefined
   }
}

int number;
bool isNumberValid;
isNumberValid = GetNumber(&number);
if (isNumberValid)
    ... do something with number

Answer 4

Simple solution:

boost::optional<int> getNumber( )
{
  // May now return an int, or may return nothing.
}

Answer 5

For float and double there is an alternative but not for int types.

#include <limits>

double Get()
{
  // no valid return value
  return std::numeric_limits<double>::quiet_NaN();
}

double val = Get();
if(val != val) {
  // Retrieved no valid return value 
}
else {
  // No NaN retrieved
}

Be careful when using NaN. Each condition on val will be true.

Answer 6

Make it a requirement for the user to check first that the queue is not empty (provide means for that).

Then you can:

• not check anything and simply invoke undefined behavior (access underlying data as if it was there) - it's the user's fault
• check and throw exception
• assert (result is undefined with NDEBUG)

Checking and then invoking undefined behavior (returning an arbitrary value) is the worst thing to do. You get both the runtime overhead of the check and the caller is no wiser, as the result is still undefined.

Answer 7

You could throw a specified exception and catch it accordingly.

Answer 8

You could also return a class/struct with some magic conversion that is useful for your special need.

Real-life example: once I had actually to return two pieces of information in the same return value, a value to report if a window message had been completely processed and the value to be returned for it if the processing was already completed. So I packed everything up in a class like this:

//This class is used to carry a return value for a window message and a value that indicates if the
//message has already been completely processed
class MessageReturnValue
{
public:
    LRESULT returnValue;
    bool processed;
    MessageReturnValue()
    {
        processed=false;
        returnValue=FALSE;
    };
    MessageReturnValue(LRESULT ReturnValue)
    {
        processed=true;
        returnValue=ReturnValue;
    };
    MessageReturnValue(bool Processed)
    {
        returnValue=FALSE;
        processed=Processed;
    };
    inline operator bool()
    {
        return processed;
    };
    inline operator LRESULT()
    {
        return returnValue;
    };
};

This allowed me to do just return false; in a function that returned a MessageReturnValue if the message had still to be processed, or to return TRUE/15/whatever; if the message had been completely processed and I already had a return value. The caller, on its side, could simply do

LRESULT MyWndProc(/* blah blah blah */)
{
    MessageReturnValue ret = MyFunction(/* blah blah blah */);
    if(!ret)
    {
        /* process the message */
        return /* something */;
    }
    else
        return (LRESULT)ret;
}

If you have more complicated needs, you could also consider using boost::tuple.