Swift 泛型

封面图 • 2025-10-24 • Swift

在 Swift 中，**泛型（Generics）** 是一种让代码可以灵活地处理多种数据类型的能力。它允许你编写 **可重用的函数、类、结构体和枚举**，而无需为每种可能的数据类型都写一遍代码。

---

## ✅ 一、为什么需要泛型？

假设你有一个函数，用于交换两个变量的值：

```swift
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}
```

这个函数只能处理 `Int` 类型。如果要交换 `String` 或 `Double`，就需要再写一个类似的函数，这显然很不高效。

泛型就可以解决这个问题。

---

## ✅ 二、基本泛型函数

使用 `<T>` 来表示类型参数：

```swift
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}
```

### 使用示例：

```swift
var x = 10
var y = 20
swapTwoValues(&x, &y)
print("x = $x, y = $y)") // 输出：x = 20, y = 10

var a = "Hello"
var b = "World"
swapTwoValues(&a, &b)
print("a = $a, b = $b)") // 输出：a = World, b = Hello
```

---

## ✅ 三、泛型函数的约束（Where）

你可以对泛型添加限制，例如要求类型实现某个协议：

```swift
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
```

> `Equatable` 协议允许使用 `==` 比较。

---

## ✅ 四、泛型结构体 / 类 / 枚举

### 1. 泛型结构体

```swift
struct Stack<Element> {
    var items = [Element]()
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element {
        return items.removeLast()
    }
}
```

### 使用示例：

```swift
var stackOfInts = Stack<Int>()
stackOfInts.push(10)
stackOfInts.push(20)
print(stackOfInts.pop()) // 输出 20
```

---

### 2. 泛型类

```swift
class Box<T> {
    let value: T
    init(_ value: T) {
        self.value = value
    }
}
```

### 使用示例：

```swift
let box = Box<String>("Hello")
print(box.value) // 输出 Hello
```

---

### 3. 泛型枚举

```swift
enum Optional<T> {
    case some(T)
    case none
}
```

Swift 内置的 `Optional` 就是这样的泛型枚举。

---

## ✅ 五、关联类型（Associated Types）

在定义协议时，可以使用 `associatedtype` 来声明一个“占位类型”，然后在实现该协议时指定具体类型。

```swift
protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

struct Stack<T>: Container {
    var items = [T]()
    
    mutating func append(_ item: T) {
        items.append(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> T {
        return items[i]
    }
}
```

---

## ✅ 六、泛型中的 where 子句

可以在泛型中添加额外的条件：

```swift
func areElementsEqual<T: Equatable>(from array1: [T], to array2: [T]) -> Bool {
    return array1 == array2
}
```

或者更复杂的：

```swift
func findFirstIndex<T: Sequence>(of value: T.Element, in sequence: T) -> Int? where T.Element: Equatable {
    for (index, element) in sequence.enumerated() {
        if element == value {
            return index
        }
    }
    return nil
}
```

---

## ✅ 七、泛型的好处

- **代码复用性高**：同一个函数/类可以适用于多种类型。
- **类型安全**：编译器能帮你检查类型是否匹配。
- **灵活性强**：适合各种复杂的数据结构和算法。

---

## ✅ 总结

| 功能 | 示例 |
|------|------|
| 泛型函数 | `func swap<T>(_ a: inout T, _ b: inout T)` |
| 泛型结构体 | `struct Stack<Element>` |
| 泛型类 | `class Box<T>` |
| 关联类型 | `associatedtype Item` |
| where 约束 | `where T: Equatable` |

---

如果你有具体的场景或想了解某个特定的泛型应用（比如泛型方法、泛型集合等），欢迎继续提问！