Question: I'ver wondered, why is it that in front of an NSError, such as below, do we put: `&error` and not `error`?

E.g.

```
NSArray *result = [managedObjectContext executeFetchRequest:fetchRequest error:&error];

```

Hope you can explain, also is this always the way or only in certain situations this is needed? Thanks.

Answer: 
You need to take the address of `error` because the function needs to modify it. `error` is passed *by pointer*, so you need the "take address" operator `&` for it.

C and Objective-C pass parameters *by value*. If you pass `error` without an ampersand and the method that you call modifies it, your function that made the call would not see any changes, because the method would operate on its *local copy* of `NSError*`.

You know that you need an ampersand in front of the corresponding parameter if you look at the signature of the method and see `**` there:

```
- (NSArray *)executeFetchRequest:(NSFetchRequest *)request error:(NSError **)error
                                            //   ^ one                    ^^ two

```
Essentially, the root of the issue is a hack for wanting to return a second (optional) object.

How can we do this, as we can only return one thing? Well, we could return some sort of `(return_value, error)` tuple, but that's a bit unwieldy. We can have as many parameters as we like though, can we do something with those...

So, methods/functions can't modify their parameters (to be precise, they operate with a copy, so any modifications they make are local). That is to say (concurrency issues aside) the value of `fetchRequest` before the message in your question will be equal to the value of `fetchRequest` afterwards. Note the object pointed to by `fetchRequest` might change, but the value of `fetchRequest` itself won't.

This puts us in a bit of a bind. Except, wait, we know we can happily take the value of a parameter and modify what it points to! If you look at the declaration for `executeFetchRequest:error:` you'll see it takes an `NSError**`. That's "a pointer to a pointer to an `NSError`". So, we can initialise an empty/dangling `NSError*`, find the address of it (with the [unary `&` operator](http://en.wikipedia.org/wiki/Operators_in_C_and_C++#Member_and_pointer_operators)), and pass that in. The method can then assign to the `NSError*` pointed to by this.

Voila, we effectively have optional additional return values.