Swift ссылки протокола и слабый с классом

Question

Если у меня есть протокол:

protocol SomeProtocol { 
    func doSomething() 
} 

и в вспомогательном классе, у меня есть ссылка на переменный протокол:

class someClass { 
    var delegate: SomeProtocol? 
} 

потому SomeProtocol не отмеченный : class, предполагается, что delegate может быть любым, и в случае типов значений (структур и перечислений) нет необходимости в weak var, потому что типы значений не могут создавать сильные ссылки. Фактически, компилятор не разрешает weak var ни на чем, кроме классов.

Однако ничто не мешает вам от создания класса в качестве делегата и, если протокол не помечен : class (как SomeProtocol is), слабой var` не могут быть использованы, и что создает цикл сохранения.

class MyClass: NSObject, SomeProtocol { 
    func doSomething() { } 
} 

struct MyStruct: SomeProtocol { 
    func doSomething() { } 
} 

let someClass = SomeClass() 
let myStruct = MyStruct() 
someClass.delegate = myStruct 
// After myStruct gets assigned to the delegate, do the delegate and the struct refer to the same instance or does the struct get copied?D 

let myClass = MyClass() 
someClass.delegate = myClass // can't use weak var so myClass is retained 

Приведенный выше пример, в случае использования делегатов и источника данных, не должен использоваться всегда : class? В принципе, любой протокол, который используется для ведения ссылки, должен всегда ограничиваться объектами класса?

Answer 1

Право. Если вы a пытаются сломать цикл сохранения со слабой ссылкой, вы должны использовать классы, потому что модификатор weak работает только с ссылочными типами (классами).

Answer 2

: class - предпочтительный подход в большинстве случаев. Однако в качестве альтернативного ответа вы можете установить delegate = nil в методе родительского объекта deinit.

Например, скажем, родительский объект является NSOperation подкласс, который имеет свойство SomeClass, и это свойство имеет делегат, который реализует SomeProtocol:

protocol SomeProtocol { 
    func doSomething() 
} 

class SomeClass { 
    var delegate: SomeProtocol? 
} 

class CustomOperation: NSOperation { 
    let foo: SomeClass 
} 

Мы сделаем класс, который реализует протокол также:

class SomeProtocolImplementation: SomeProtocol { 
    func doSomething() { 
     print("Hi!") 
    } 
} 

Теперь мы можем назначить foo в init():

class CustomOperation: NSOperation { 
    let foo: SomeClass 

    override init() { 
     foo = SomeClass() 
     foo.delegate = SomeProtocolImplementation() 
     super.init() 
    } 
} 

Это создает цикл удержания. Тем не менее, рассмотрим этот deinit метод:

deinit { 
     foo.delegate = nil 
    } 

Теперь, когда CustomOperation будут высвобождены, foo.delegate будет установлен в nil, нарушая цикл сохранения. Затем, когда пул авторецепции сливается в конце цикла запуска, оба SomeClass и SomeProtocolImplementation будут освобождены.