为什么 Swift Class-Only 协议需要 AnyObject 继承？

Question

I am trying to figure out Swift Documentation: https://docs.swift.org/swift-book/LanguageGuide/Protocols.html

But I stuck at this issue, Why need AnyObject, I mean why i need to use that kind of restriction ? Is that a bad idea to not restrict for value and reference types just not using Any or AnyObject ?

protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
    // class-only protocol definition goes here
}

Anyone can explain me some example with codes especially will be very helpful. Thanks.

By the way that answer can be good but literally explanations made me confusing Why use class only protocols in Swift?

Answer 1

When you write a protocol, you define an interface for the types which adopt, or conform to the protocol:

// Every Greeter has a greeting message
// and a way for it to present that message.
protocol Greeter {
    var greeting: String { get }
    func greet()
}

extension Greeter {
    // Default implementation for the `greet` method.
    func greet() {
        print(self.greeting)
    }
}

This gives consistent behavior to every type which conforms and lets you treat them all in the same way regardless of what they are. For instance, a type can store a value bound to a protocol type:

struct Store {
    // The name of the store.
    var name: String

    // The address of the store.
    var address: String

    // An entity that greets customers when they walk in.
    var greeter: Greeter
}

In this case, Store.greeter can be set to any value or object which conforms to the Greeter protocol:

struct Bell: Greeter {
    let greeting = "Ding!"
}

class Person: Greeter {
    let greeting: String

    init(name: String) {
       greeting = "Welcome! My name is \(name)."
    }
}

var store = Store(name: "My Shop", address: "123 Main St.", greeter: Bell())
store.greeter.greet() // => "Ding!"

store.greeter = Person(name: "Itai")
store.greeter.greet() // => "Welcome! My name is Itai."

By default, a protocol can be adopted by both value types and object types, ie, both struct s and class es. This is a good default because in many cases, there's no reason to restrict who can conform to a protocol.

However, there is one case where this matters. By default, Store owns its greeter property, ie, when you assign an object to store.greeter , it is retained. This is normally fine, except when you have a potentially circular relationship (for example, if Person has a reference to the Store they work at).

Normally, to break a potential circular chain like this up, you would make the variable weak :

struct Store {
   // ...
   weak var greeter: Greeter?
   //       ^ error: 'weak' must not be applied to non-class-bound 'Greeter'; consider adding a protocol conformance that has a class bound
}

If you try this, though, you'll get the above error. This is because weak only makes sense for objects, not for struct s ( struct s can only be owned because they are value types — every owner just makes a copy of a struct , so there is no one central value to retain or release). In this case, to ensure a weak reference, you must ensure that Greeter an only be an object type.

The way to do this is to constrain the protocol to only allow classes to conform by using AnyObject as a constraint:

protocol Greeter: AnyObject {
    // ...
}

Now, Bell can't conform to Greeter any more ( error: non-class type 'Bell' cannot conform to class protocol 'Greeter' ) but you are allowed to have weak var greeter: Greeter? as a variable.

---

So, when should you restrict your protocol to be "class-bound" (using AnyObject )? Well, only when you really have to. The one benefit for class-bound protocols is to allow weak references to them, and the main use-case for that is with delegate references to prevent circular retains.

For instance, UITableView has a weak delegate property because the delegate object is usually the view controller which owns the UITableView object itself. If the view controller retains the table view, and the table view retains the controller, neither can be released automatically.

So, in the general case, you don't need to worry about the AnyObject constraint unless you really do only want classes to conform to the protocol.