Generische Funktionen und Typen

Warum Generics?

Generische Funktion

// Generic swap for any type T
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 1, y = 2
swapValues(&x, &y)
print(x, y)  // 2 1

var s1 = "A", s2 = "B"
swapValues(&s1, &s2)
print(s1, s2) // B A

Generischer Typ

// A minimal generic stack
struct Stack<Element> {
    private var items: [Element] = []
    mutating func push(_ x: Element) { items.append(x) }
    mutating func pop() -> Element? { items.popLast() }
    var top: Element? { items.last }
}

var intStack = Stack<Int>()
intStack.push(10); intStack.push(20)
print(intStack.top ?? -1)   // 20

var textStack = Stack<String>()
textStack.push("hi"); textStack.push("bye")
print(textStack.pop() ?? "?")

Typinferenz

// The compiler infers T from arguments/assignments
func makePair<T>(_ a: T, _ b: T) -> (T, T) { (a, b) }

let pair1 = makePair(1, 2)          // T inferred as Int
let pair2 = makePair("a", "b")      // T inferred as String
print(pair1, pair2)

Duplizierung vermeiden

// Non-generic overloads would duplicate logic:
func eqInt(_ a: Int, _ b: Int) -> Bool { a == b }
func eqStr(_ a: String, _ b: String) -> Bool { a == b }
// A single generic can replace both:

Hinweise und Benennung

Bedeutung von <T>

Zusammenfassung