Overloading di funzioni in

Informazioni su Overloading di funzioni

In Swift puoi definire più funzioni con lo stesso nome, purché le loro firme siano diverse. Questa pratica è nota come sovraccarico di funzioni.

Considera la seguente funzione di base:

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, due funzioni con lo stesso nome sono considerate distinte se è soddisfatta una qualsiasi delle seguenti condizioni:

• Hanno un numero diverso di parametri.
• Hanno etichette degli argomenti esterne diverse.
• Hanno tipi dei parametri diversi.
• Hanno tipi restituiti diversi (a condizione che il contesto della chiamata chiarisca quale usare).

Data la funzione add originale qui sopra, ognuno dei seguenti sovraccarichi è distinto e valido nello stesso programma:

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

Sovraccarico tramite il tipo restituito

Le funzioni possono anche essere sovraccaricate esclusivamente in base al tipo restituito. Tuttavia, quando chiami una funzione di questo tipo, devi fornire un'annotazione di tipo o un contesto, così che il compilatore sappia quale sovraccarico intendi usare:

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

Cosa non distingue i sovraccarichi

Cambiare solo il nome interno del parametro senza modificare l'etichetta dell'argomento, il tipo del parametro o il numero di parametri non crea una funzione distinta. Il compilatore la considera una dichiarazione duplicata non valida:

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