Question marks after a type refer to Optionals, a way in Swift which lets you indicate the possibility that a value might be absent for any type at all, without the need for special constants.
It's used in the same situations you'd explicitly return nil in Objective-C, when there is no object to be returned, or for values that are not objects, constants such as NSNotFound. Optionals provide a consistent way of achieving this across all data types.
From the Apple provided iBook
You use optionals in situations where a value may be absent. An
optional says:
- There is a value, and it equals x
or
- There isn’t a value at all
Here’s an example. Swift’s String type has a method called toInt,
which tries to convert a String value into an Int value. However, not
every string can be converted into an integer. The string "123" can be
converted into the numeric value 123, but the string "hello, world"
does not have an obvious numeric value to convert to.
let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type "Int?", or "optional Int"
Because the toInt method might fail, it returns an optional Int,
rather than an Int. An optional Int is written as Int?, not Int. The
question mark indicates that the value it contains is optional,
meaning that it might contain some Int value, or it might contain no
value at all. (It can’t contain anything else, such as a Bool value or
a String value. It’s either an Int, or it’s nothing at all.)
There is a whole section on the language reference iBook on Optionals, and they are mentioned several times throughout the book. You should have a thorough look at it, since it's a fundamental concept of Swift programming, and one that is not prevalent in many other languages.
