Funktionsüberladung in

Über Funktionsüberladung

In Swift kannst du mehrere Funktionen mit demselben Namen definieren, solange sich ihre Signaturen unterscheiden. Dieses Vorgehen nennt man Funktionsüberladung.

Schauen wir uns die folgende Basisfunktion an:

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

In Swift gelten zwei Funktionen mit demselben Namen als verschieden, wenn eine der folgenden Bedingungen erfüllt ist:

• Sie haben eine unterschiedliche Anzahl von Parametern.
• Sie haben unterschiedliche externe Argumentbezeichnungen.
• Ihre Parametertypen unterscheiden sich.
• Ihre Rückgabetypen unterscheiden sich (sofern der aufrufende Kontext klarstellt, welche du verwenden möchtest).

Ausgehend von der ursprünglichen add-Funktion oben ist jede der folgenden Überladungen eigenständig und im selben Programm gültig:

// 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

Überladung über den Rückgabetyp

Funktionen können auch allein über ihren Rückgabetyp überladen werden. Wenn du eine solche Funktion aufrufst, musst du jedoch eine Typannotation oder einen Kontext angeben, damit der Compiler weiß, welche Überladung du meintest:

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

Was Überladungen nicht unterscheidet

Wenn du nur den internen Parameternamen änderst und dabei die Argumentbezeichnung, den Parametertyp oder die Parameteranzahl unverändert lässt, entsteht keine eigenständige Funktion. Der Compiler behandelt das als ungültige doppelte Deklaration:

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:)'