Függvénytúlterhelés ebben a kurzusban:

A(z) Függvénytúlterhelés fogalomról

Swiftben több azonos nevű függvényt is definiálhatsz, amíg a szignatúrájuk eltér. Ezt a gyakorlatot függvénytúlterhelésnek nevezik.

Vegyük a következő alapfüggvényt:

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

Swiftben két azonos nevű függvény akkor számít különbözőnek, ha az alábbi feltételek bármelyike teljesül:

• Eltér a paramétereik száma.
• Eltérnek a külső argumentumcímkéik.
• Eltérnek a paramétertípusaik.
• Eltér a visszatérési típusuk (feltéve, hogy a hívási kontextus egyértelművé teszi, melyiket kell használni).

A fenti eredeti add függvény ismeretében az alábbi túlterhelések mindegyike különböző, és érvényes ugyanabban a programban:

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

Túlterhelés visszatérési típus szerint

A függvényeket kizárólag a visszatérési típusuk alapján is túlterhelheted. Amikor azonban egy ilyen függvényt hívsz, típusmegjelölést vagy kontextust kell adnod, hogy a fordító tudja, melyik túlterhelést akartad:

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

Mi nem különböztet meg túlterheléseket

Ha csak a belső paraméternevet változtatod meg, az argumentumcímkét, a paramétertípust vagy a paraméterszámot nem, az nem hoz létre különböző függvényt. A fordító érvénytelen ismételt deklarációként kezeli:

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