从常规方法调用协议默认实现

我想知道是否有可能实现这样的目标。
我有一个这样的游乐场：

protocol Foo {
    func testPrint()
}

extension Foo {
    func testPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        // Calling self or super go call default implementation
        self.testPrint()
        print("Call from struct")
    }
}


let sth = Bar()
sth.testPrint()

我可以在中提供默认实现，extension但是如果Bar需要默认实现中的所有内容以及其他内容，该怎么办？
它在某种程度上类似于es中的调用super.方法，class可以满足实现每个属性等的要求structs。

我不知道您是否还在寻找答案，但是要做的方法是从协议定义中删除函数，将对象转换为对象Foo，然后在其上调用方法：

protocol Foo { 
    // func testPrint() <- comment this out or remove it
}

extension Foo {
    func testPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        print("Call from struct")
        (self as Foo).testPrint() // <- cast to Foo and you'll get the  default
                                  //    function defined in the extension
    }
}

Bar().testPrint()

// Output:    "Call from struct"
//            "Protocol extension call"

由于某种原因，它仅在函数未声明为协议的一部分但在协议的扩展中定义时才起作用。去搞清楚。但这确实有效。

好吧，您可以创建一个符合协议的嵌套类型，实例化它，然后在该类型上调用该方法（没关系，因为协议扩展内部的实现无法引用它，因此您无法访问类型的数据）。但这不是我所说的优雅的解决方案。

struct Bar: Foo {
    func testPrint() {
        // Calling default implementation
        struct Dummy : Foo {}
        let dummy = Dummy()
        dummy.testPrint()
        print("Call from struct")
    }
}

感谢您的帖子！如果将函数定义放在协议中，则当将该对象强制转换为协议时，它只会看到该对象的函数版本，并且由于您在内部调用它，因此可以获取Apple的新地址。

我确实尝试过这样的版本：

import UIKit
protocol MyProc
{
}

protocol MyFuncProc
{
    func myFunc()
}

extension MyProc
{
    func myFunc()
    {
        print("Extension Version")
    }
}

struct MyStruct: MyProc, MyFuncProc
{
    func myFunc()
    {
        print("Structure Version")
        (self as MyProc).myFunc()
    }
}

(MyStruct() as MyFuncProc).myFunc()

输出为：

Structure Version
Extension Version

如果你的协议具有associatedType或Self要求，那么中投将无法正常工作。要变通解决此问题，请创建一个“影子”默认实现，常规默认实现和符合性类型都可以调用该默认实现。

protocol Foo { 
    associatedType Bar
}

extension Foo {
    func testPrint() {
        defaultTestPrint()
    }
}

fileprivate extension Foo { // keep this as private as possible
    func defaultTestPrint() {
        // default implementation
    }
}

struct Bar: Foo {
    func testPrint() {
        // specialized implementation
        defaultTestPrint()
    }
}

您如何看待这种解决方案？

protocol Foo {
    func testPrint()
}

extension Foo {
    func testPrint() {
        defaultTestPrint()
    }

    func defaultTestPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        // Calling self or super go call default implementation
        defaultTestPrint()
        print("Call from struct")
    }
}


let sth = Bar()
sth.testPrint()