泛型函数

概述

泛型（Generics）是Swift中一个非常强大的特性，它允许你编写灵活且可重用的代码。泛型函数是其中的一种应用，它允许你编写一个函数，可以处理多种不同类型的数据，而不需要为每种类型编写单独的函数。

为什么需要泛型函数？

在编程中，我们经常需要编写处理不同数据类型的函数。例如，你可能需要编写一个函数来交换两个整数的值，另一个函数来交换两个字符串的值。如果没有泛型，你需要为每种类型编写单独的函数，这会导致代码冗余且难以维护。

泛型函数通过使用占位符类型（通常用大写字母表示，如T）来解决这个问题。你只需要编写一个泛型函数，它可以处理任何类型的数据。

泛型函数的基本语法

泛型函数的基本语法如下：

func 函数名<T>(参数1: T, 参数2: T) -> T {
    // 函数体
}

在这个语法中：

• T 是一个占位符类型，表示任何类型。
• 函数名<T> 表示这是一个泛型函数。
• 参数1: T 和 参数2: T 表示参数的类型是 T。
• -> T 表示函数的返回值类型是 T。

示例：交换两个值

让我们通过一个简单的例子来理解泛型函数。假设我们需要编写一个函数来交换两个变量的值。

非泛型版本

首先，我们来看一个非泛型版本的交换函数：

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

这个函数只能交换两个整数的值。如果我们需要交换两个字符串的值，我们需要编写另一个函数：

func swapTwoStrings(_ a: inout String, _ b: inout String) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someString = "hello"
var anotherString = "world"
swapTwoStrings(&someString, &anotherString)
print("someString is now \(someString), and anotherString is now \(anotherString)")

泛型版本

使用泛型函数，我们可以编写一个通用的交换函数：

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

var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
print("someString is now \(someString), and anotherString is now \(anotherString)")

在这个泛型版本中，T 是一个占位符类型，表示任何类型。我们可以使用这个函数来交换任何类型的值，而不需要为每种类型编写单独的函数。

泛型函数的类型约束

有时候，你可能希望泛型函数只处理某些特定类型的数据。例如，你可能希望一个函数只处理实现了某个协议的类型。这时，你可以使用类型约束。

类型约束语法

类型约束的语法如下：

func 函数名<T: 协议名>(参数1: T, 参数2: T) -> T {
    // 函数体
}

在这个语法中，T: 协议名 表示 T 必须遵循指定的协议。

示例：只处理可比较的类型

假设我们需要编写一个函数来比较两个值，并返回较大的那个值。我们可以使用类型约束来确保这个函数只处理可比较的类型（如整数、浮点数、字符串等）。

func max<T: Comparable>(_ a: T, _ b: T) -> T {
    return a > b ? a : b
}

let maxInt = max(3, 10)
print("The max value is \(maxInt)")

let maxString = max("hello", "world")
print("The max value is \(maxString)")

在这个例子中，T: Comparable 表示 T 必须遵循 Comparable 协议，这意味着 T 必须支持比较操作（如 >、< 等）。

实践练习

练习1：泛型数组求和

编写一个泛型函数 sumArray，它接受一个数组作为参数，并返回数组中所有元素的和。你可以假设数组中的元素是可加的（如整数、浮点数等）。

func sumArray<T: Numeric>(_ array: [T]) -> T {
    return array.reduce(0, +)
}

let intArray = [1, 2, 3, 4, 5]
let sumOfInts = sumArray(intArray)
print("Sum of intArray is \(sumOfInts)")

let doubleArray = [1.1, 2.2, 3.3, 4.4, 5.5]
let sumOfDoubles = sumArray(doubleArray)
print("Sum of doubleArray is \(sumOfDoubles)")

练习2：泛型栈

编写一个泛型栈（Stack）类，支持以下操作：

• push(_ element: T)：将元素压入栈顶。
• pop() -> T?：弹出栈顶元素，如果栈为空则返回 nil。
• isEmpty() -> Bool：检查栈是否为空。

struct Stack<T> {
    private var elements: [T] = []

    mutating func push(_ element: T) {
        elements.append(element)
    }

    mutating func pop() -> T? {
        return elements.popLast()
    }

    func isEmpty() -> Bool {
        return elements.isEmpty
    }
}

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
intStack.push(3)

while !intStack.isEmpty() {
    if let value = intStack.pop() {
        print("Popped value: \(value)")
    }
}

总结

泛型函数是Swift中一个非常强大的特性，它允许你编写灵活且可重用的代码。通过使用泛型，你可以编写一个函数来处理多种不同类型的数据，而不需要为每种类型编写单独的函数。类型约束可以进一步限制泛型函数处理的类型，使其更加安全和可靠。

通过本教程的学习，你应该已经掌握了泛型函数的基本概念和使用方法。希望你能在实际编程中灵活运用泛型，编写出更加简洁和高效的代码。