Swift 方法调度很奇怪：被覆盖的方法使用超类的默认参数值

这是一种非常古老、有争议的行为。简短的回答是：不要那样做。关于这是一个错误还是一个设计选择，存在相当多的争论。

我个人的看法是，这应该是一个编译器错误，或者至少是一个警告。IMO，B 中的函数是不同的函数，因此不会覆盖 A（所以应该是一个错误）。或者它是“相同”的功能，但以某种方式具有不同的签名，这也应该是一个错误。至少有一个开放的错误可以使其成为警告（嗯，类似的东西，但它在同一个球场上）。override

但事实就是如此，我怀疑改变它是否会有太大的兴趣。这将是一个重大变化，所以无论如何我都不会期望它在 Swift 6 之前出现。由于继承不是 Swift 中的首选方法，因此大多数新功能都集中在使用结构、枚举或参与者的更首选方法上。所以我真的不指望在 Swift 6 中出现它。当然，如果它对你很重要，我会在论坛上提出来，并做一个推销。如果您感兴趣，至少发出警告可能是一个非常好的入门错误。

与大多数涉及默认值的问题一样，解决方案始终是记住它们实际上是更明确的语法的简写：

class A {
    func execute() {
        execute(param: 123)
    }

    func execute(param: Int) {
        print("A: \(param)")
    }
}

class B: A {
    override func execute() {
        execute(param: 456)
    }

    override func execute(param: Int) {
        print("B: \(param)")
    }
}

或者，您可以使用我一直认为对默认参数有用的技术。将它们指定为 Optional，并在实现中分配其默认值：

class A {
    func execute(param: Int? = nil) {
        let param = param ?? 123
        print("A: \(param)")
    }

}

class B: A {
    override func execute(param: Int? = nil) {
        let param = param ?? 456
        print("B: \(param)")
    }
}

这是我一直在发现的一种技术，如果这些默认值可能会访问属性，那么我经常需要使用默认值的方法。它也适用于这种情况。actor@MainActor

（但你感到惊讶是对的。多年来，人们一直对此感到惊讶。

你在评论中问了到底发生了什么，这也是一个好问题。正如您所料，答案在 SIL 中（添加了评论）：

  # ...
  # Take the B just created in %6 and upcast it to A; store in %9
  %7 = upcast %6 : $B to $A                       // user: %8
  store %7 to %3 : $*A                            // id: %8
  %9 = load %3 : $*A                              // users: %12, %13

  # Look up the default parameter A.execute(param:), since %9 is of type A
  // function_ref default argument 0 of A.execute(param:)
  %10 = function_ref @$s1x1AC7execute5paramySi_tFfA_ : $@convention(thin) () -> Int // user: %11
  %11 = apply %10() : $@convention(thin) () -> Int // user: %13


  # And apply the function `execute` to %9
  %12 = class_method %9 : $A, #A.execute : (A) -> (Int) -> (), $@convention(method) (Int, @guaranteed A) -> () // user: %13
  %13 = apply %12(%11, %9) : $@convention(method) (Int, @guaranteed A) -> ()

默认参数实际上是一个函数：

// default argument 0 of A.execute(param:)
sil hidden @$s1x1AC7execute5paramySi_tFfA_ : $@convention(thin) () -> Int {
bb0:
  %0 = integer_literal $Builtin.Int64, 123        // user: %1
  %1 = struct $Int (%0 : $Builtin.Int64)          // user: %2
  return %1 : $Int                                // id: %2
} // end sil function '$s1x1AC7execute5paramySi_tFfA_'

因此，由于是静态的类型（这是编译器所知道的），因此代码被转换为：instanceAinstance.execute()

func defaultArg0OfAExecuteParam() { 123 }

// ...

let param = defaultArg0OfAExecuteParam()
instance.execute(param: param)

所有选择都是在调用方的点上做出的，而不是在实现点上做出的。因此，默认值完全取决于静态已知的类型信息。

按照你所期望的方式工作将是 Swift 工作方式的重大变化，我不认为这是合理的，甚至不是特别可取的，因为它可能会减少内联和其他优化的机会。但是，IMO，允许这种情况的事实是一个错误。