swift泛型

泛型

泛型可以将类型参数化，提高代码复用率，减少代码量

func swapValues(_ a: inout T, _ b: inout T) { 
  (a, b) = (b, a) 
}

// 泛型函数赋值给变量
func test(_ t1: T1, _ t2: T2) {} 
var fn: (Int, Double) -> () = test

使用泛型实现栈

class Stack { 
  var elements = [E]() 
  func push(_ element: E) { elements.append(element) } 
  func pop() -> E { elements.removeLast() } 
  func top() -> E { elements.last! } 
  func size() -> Int { elements.count } 
}   

// 泛型栈继承
class SubStack : Stack {}


struct Stack { 
  var elements = [E]() 
  mutating func push(_ element: E) { elements.append(element) } 
  mutating func pop() -> E { elements.removeLast() } 
  func top() -> E { elements.last! }
  func size() -> Int { elements.count } 
}

关联类型（Associated Type）

关联类型的作用：给协议中用到的类型定义一个占位名称

协议中可以拥有多个关联类型

protocol Stackable { 
  associatedtype Element // 关联类型 
  mutating func push(_ element: Element) 
  mutating func pop() -> Element 
  func top() -> Element 
  func size() -> Int 
}


class Stack : Stackable {
    // typealias Element = E 
  var elements = [E]() 
  func push(_ element: E) { elements.append(element) } 
  func pop() -> E { elements.removeLast() } 
  func top() -> E { elements.last! } 
  func size() -> Int { elements.count }
}


class StringStack : Stackable {
  // 给关联类型设定真实类型 
  // typealias Element = String 
  var elements = [String]() 
  func push(_ element: String) { elements.append(element) } 
  func pop() -> String { elements.removeLast() } 
  func top() -> String { elements.last! } 
  func size() -> Int { elements.count }
}
var ss = StringStack() 
ss.push("Jack") 
ss.push("Rose")

类型约束

protocol Runnable { } 
class Person { } 
func swapValues(_ a: inout T, _ b: inout T) { 
    (a, b) = (b, a) 
}

protocol Stackable { 
  associatedtype Element: Equatable
} 
class Stack : Stackable { 
  typealias Element = E 
}

func equal(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable { 
  return false 
}

var stack1 = Stack() 
var stack2 = Stack() 
// error: requires the types 'Int' and 'String' be equivalent 
equal(stack1, stack2)

协议类型作为返回值

func get(_ type: Int) -> T { 
  if type == 0 { 
    return Person() as! T 
  } 
  return Car() as! T 
} 
var r1: Person = get(0) 
var r2: Car = get(1)

不透明类型（Opaque Type）

使用some关键字声明一个不透明类型

some限制只能返回一种类型

func get(_ type: Int) -> some Runnable { 
    Car() 
} 
var r1 = get(0)
var r2 = get(1)

some

some

some除了用在返回值类型上，一般还可以用在属性类型上

protocol Runnable { associatedtype Speed } 
class Dog : Runnable { typealias Speed = Double } 
class Person {
    var pet: some Runnable {
        return Dog()
  } 
}