在Swift中存储对struct的引用

Question

Let's say I have a model, called Car with a property color of type String :

class Car {
    var color: String?
}

Now, I have another class called Interface that I wish to use to modify the value of the color property of Car . To do this, I'd like to somehow bind color to a property of Interface , such as key :

class Interface {

    var storedKey: String?

    func bind(key: String?) {
        self.storedKey = key
    }
}

Usage:

let corolla = Car()
corolla.color = "green"
let interface = Interface()
interface.bind(key: &corolla.color)
interface.storedKey = "blue"
print(corolla.color) // still "green"! :(

This approach fails because strings are value types (structs) in Swift, so the bind function gets a copy of corolla.color , not a reference. This means modifying storedKey of interface has no effect on the value of corolla.color .

If we add inout to the binding function as shown below, we basically obtain a reference to the key passed in ( it's actually copied in then copied out ), but it only lasts for the scope of the function.

func bind(key: inout String?) {
    self.storedKey = key  // assignment of value type is a copy! :/
}

The results are the same, modifying storedKey has no effect on the property it is bound to.

What this boils down to is, can we obtain a reference to a struct in Swift?

---

Since structs occupy space in memory, we may be able to obtain a pointer to the key passed in, here is a working (incorrect) solution:

class Car {
    var color: String?
}

let corolla = Car()
corolla.color = "green"

class Interface {

    var storedKey: UnsafeMutablePointer<String?>?

    func bind(_ key: inout String?) {
        self.storedKey = withUnsafeMutablePointer(to: &key) { ptr in
            return ptr
        }
    }
}

var interface = Interface()
interface.bind(&corolla.color)
interface.storedKey?.pointee = "blue" // :O it's... working?
print(corolla.color)

As I see it, this breaks at least two semantic rules in Swift:

1. withUnsafeMutablePointer converts the address of an instance passed in via & to a UnsafeMutablePointer of that instances' type, to be used only within the provided closure. As per the Swift docs :

   The pointer argument to body is valid only for the lifetime of the closure. Do not escape it from the closure for later use.

2. The second problem is that this takes advantage of a Swift compiler optimization that allows bind to actually obtain a reference to key instead of a copy. Otherwise, the pointer would not obtain a reference to the original key, but to a copy. inout parameters are normally implemented using a behavior known as copy-in copy-out, whereby a copy of the argument is passed in to the function, possibly modified, and then assigned back to the original argument. As per the docs , there is an optimization whereby if the argument is a stored property, the same memory location is used both inside and outside the function body. This allowed our pointer to obtain a reference to the original String struct instead of a copy, allowing this to work.

   As an optimization, when the argument is a value stored at a physical address in memory, the same memory location is used both inside and outside the function body.

Is there any way to store a reference to a struct such as String ? Or am I on a wild goose chase?

Edit 1: Also, I have no control of the types of Car 's properties.

Answer 1

You can't get a reference to your struct as you already researched.

What you can do is use a Box class and pass that around.

Then you would use the Box everywhere and access its struct property wherever needed.

Something like:

class Box<T> {
   var value: T
   init(value: T) {
      self.value = value
   }
}

and use it with a Car

let boxedCar = Box(value: Car(...)) 

You can share references to this box and always access the car through the value property