I understand what the @try and @catch blocks do, but what does @throw do?
@try{
/**Insert code here**/
}
@catch(NSException * myException){
/**insert code **/
}
Where does @throw fit in all this? A simple example would be really helpful.
I checked out this link but couldn't find the answer I was looking for.
Exceptions in Objective-C are used mainly for cases of obvious programmer error, such as attempting to access an element outside the bounds of an NSArray. In contrast, some programming languages use exceptions to specify any sort of recoverable error such as "file not found", but in Objective-C and Cocoa, an NSException that has been thrown with @throw typically means there is nothing that can be done to recover.
In either case, the analogy is that exceptions are "thrown" to the catcher, no matter how many function calls sit between the thrower and the catcher. This is in contrast to functions that return error statuses through return values or output parameters. Functions that return error statuses need to ensure that all other functions in the chain return the same error status in order for the original caller at the other end to know there was an error. Exceptions that are thrown bypass all intermediate functions and give the error straight to where it is wanted, the original call-site.
void function3()
{
@throw [NSException exceptionWithName:@"Test" reason:@"Test" userInfo:nil];
}
void function2()
{
function3();
}
void function1()
{
function2();
}
int main()
{
@try
{
function1();
}
@catch(NSException *ex)
{
// handle exception that occurred 3 functions deep
}
}
In general, you should avoid throwing exceptions in Objective-C as a general means of catching recoverable errors because of the way memory management works. In the above, if any objects were allocated in function1, function2 or function3 but were not autoreleased, then the memory for these objects would be leaked. ARC with "full exception safety" enabled is capable of detecting these cases and handling them appropriately but this only applies for objects in your own code, not any memory allocated by external libraries that you could be using. There is the general expectation that your application will not recover from an exception thrown with @throw.
See more details in this Q&A.
@throw lets you, wait for it, throw an exception, and why we want to throw an exception? We throw exceptions when exceptional things happen, for example, in the following code, it doesn't make sense that the inventory array size is zero, so we throw an exception, for that special case.
NSString *getRandomCarFromInventory(NSArray *inventory) {
int maximum = (int)[inventory count];
if (maximum == 0) {
NSException *e = [NSException
exceptionWithName:@"EmptyInventoryException"
reason:@"*** The inventory has no cars!"
userInfo:nil];
@throw e;
}
int randomIndex = arc4random_uniform(maximum);
return inventory[randomIndex];
}
This example an further information on: http://rypress.com/tutorials/objective-c/exceptions.html (emphasis mine)
Two distinct types of problems can arise while an iOS or OS X application is running. Exceptions represent programmer-level bugs like trying to access an array element that doesn’t exist. They are designed to inform the developer that an unexpected condition occurred. Since they usually result in the program crashing, exceptions should rarely occur in your production code.
If an operation fails and raises an exception, like in:
@try{ // code fails and raises an exception
if (!objectNotInMemory)
{
@throw exc; // presuming you already initialized NSException* exc
}
}
@catch (NSException* e){ // deal with exception exc
if ([[e reason] isEqualToString:@"Object not in memory"])
UIAlertView* alert = [UIAlertView initWith...];
}
the thing raising that exception (in this case, objectNotInMemory being nonexistent, nil, or 0) has an @throw{} directive that creates or passes an NSException object or message of some sort. This exception object can then be caught in an @catch{} block or if ignored, will alert the operating system to shutdown the application process.
An exception must be thrown to be caught.
More reading from Apple's docs (which you should get comfortable with):
@try —Defines a block of code that is an exception handling domain: code that can potentially throw an exception.
@catch() —Defines a block containing code for handling the exception thrown in the @try block. The parameter of @catch is the exception object thrown locally; this is usually an NSException object, but can be other types of objects, such as NSString objects.
@finally — Defines a block of related code that is subsequently executed whether an exception is thrown or not.
@throw — Throws an exception; this directive is almost identical in behavior to the raise method of NSException. You usually throw NSException objects, but are not limited to them. For more information about @throw, see “Throwing Exceptions.”
