Reference Semantics
suggest changeClasses are reference types, meaning that multiple variables can refer to the same instance.
the samealso modifies firstDog
Because classes are reference types, even if the class is a constant, its variable properties can still be modified.
class Dog {
var name: String // name is a variable property.
let age: Int // age is a constant property.
init(name: String, age: Int) {
self.name = name
self.age = age
}
}
let constantDog = Dog(name: "Rover", age: 5)// This instance is a constant.
var variableDog = Dog(name: "Spot", age 7)// This instance is a variable.
constantDog.name = "Fido" // Not an error because name is a variable property.
constantDog.age = 6 // Error because age is a constant property.
constantDog = Dog(name: "Fido", age: 6)
/* The last one is an error because you are changing the actual reference, not
just what the reference points to. */
variableDog.name = "Ace" // Not an error because name is a variable property.
variableDog.age = 8 // Error because age is a constant property.
variableDog = Dog(name: "Ace", age: 8)
/* The last one is not an error because variableDog is a variable instance and
therefore the actual reference can be changed. */
Test whether two objects are identical (point to the exact same instance) using ===
:
class Dog: Equatable {
let name: String
init(name: String) { self.name = name }
}
// Consider two dogs equal if their names are equal.
func ==(lhs: Dog, rhs: Dog) -> Bool {
return lhs.name == rhs.name
}
// Create two Dog instances which have the same name.
let spot1 = Dog(name: "Spot")
let spot2 = Dog(name: "Spot")
spot1 == spot2 // true, because the dogs are equal
spot1 != spot2 // false
spot1 === spot2 // false, because the dogs are different instances
spot1 !== spot2 // true
Found a mistake? Have a question or improvement idea?
Let me know.
Table Of Contents