函数重载 属于

关于 函数重载

在 Swift 中，只要签名不同，你就可以定义多个同名函数。 这种做法称为函数重载。

请看以下基础函数：

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = x + y
    return doubleResult ? sum * 2 : sum
}

let twentySix = add(6, and: 7, doubleResult: true)
// => 26

在 Swift 中，如果满足以下任一条件，两个同名函数就被视为不同：

• 形参数量不同。
• 外部实参标签不同。
• 形参类型不同。
• 返回类型不同（前提是调用上下文能明确该用哪一个）。

对于上面原始的add函数，以下每个重载在同一程序中都是不同且有效的：

// 1. Different number of parameters
func add(_ x: Int, and y: Int) -> Int {
    x + y
}

let eleven = add(5, and: 6)
// => 11

// 2. Different parameter type (Double instead of Int)
func add(_ x: Double, and y: Int, doubleResult: Bool) -> Double {
    let sum = x + Double(y)
    return doubleResult ? sum * 2 : sum
}

let twentySeven = add(6.5, and: 7, doubleResult: true)
// => 27.0

// 3. Different argument label (doubleThat instead of doubleResult)
func add(_ x: Int, and y: Int, doubleThat: Bool) -> Int {
    let sum = x + y
    return doubleThat ? sum * 2 : sum
}

let thirteen = add(6, and: 7, doubleThat: false)
// => 13

按返回类型重载

函数也可以仅根据返回类型进行重载。 但是，调用这样的函数时，你必须提供类型标注或上下文，以便编译器知道你想用的是哪个重载：

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Double {
    let sum = Double(x + y)
    return doubleResult ? sum * 2 : sum
}

// Ambiguous call (compiler cannot decide whether you want Int or Double):
// let thirty = add(6, and: 9, doubleResult: true)

// Resolved with an explicit type annotation:
let thirty: Double = add(6, and: 9, doubleResult: true)
// => 30.0

不能区分重载的情况

仅更改内部形参名而不更改实参标签、形参类型或形参数量，不会创建不同的函数。 编译器会将其视为无效的重复声明：

func add(_ w: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = w + y
    return doubleResult ? sum * 2 : sum
}
// Error: Invalid redeclaration of 'add(_:and:doubleResult:)'