写在前面：
泛型,类似于OC中的id类型，它可以指代任何一种类型，并不是在编译时确定其类型，而是在运行时确定其实际类型。使用泛型的函数，我们称之为泛型函数
intout关键字
现有两变量，要求其值互换
var someStr = "I am A"
var anotherStr = "I am B"
如果方法中参数得值在方法内部不会发生变化
即参数为常量，用let声明，let可省略
func swapTwoStrings1( a: String, b: String) {
let tempA = b //对形参a的值不发生变化
let tempB = a //对形参b的值不发生变化
}
someStr //"I am A" 对实参someStr的值不发生变化
anotherStr //"I am B" 对实参anotherStr的值不发生变化
如果方法中的参数的值在方法内部会发生变化
参数需声明为变量，用var声明，var不可省略
func swapTwoStrings2(var a: String, var b: String) {
let temporaryA = a
a = b //方法内a的值发生了改变
b = temporaryA //方法内b的值发生了改变
}
swapTwoStrings2(someStr, b: anotherStr)
someStr //"I am A" 方法外someStr的值未改变
anotherStr //"I am B" 方法外anotherStr的值未改变
如果想让传入的参数在进入方法后发生改变(参数在进入方法后值发生真正改变)
使用inout关键字(使形参和实参指向的内存一致)
func swapTwoStrings3(inout a: String, inout b: String) {
let temporaryA = a
a = b //方法内a的值发生了改变
b = temporaryA //方法内b的值发生了改变
}
//传递参数时多出现了"&"符号，其实传递了字符串的地址
swapTwoStrings3(&someStr, b: &anotherStr)
someStr //"I am B" 方法外someStr的值发生改变
anotherStr //"I am A" 方法外anotherStr的值发生改变
注意：inout修饰的参数是不能有默认值的，有范围的参数集合也不能被修饰，另外，一个参数一旦被inout修饰，就不能再被var和let修饰了
泛型
上面的方法是为了把两个String变量的值相互交换
现要求把两个Int变量的值相互交换
func swapTwoInts(inout a: Int, inout b: Int){
let temporaryA = a
a = b
b = temporaryA
}
从方法结构来看，swapTwoStrings3和swapTwoInts两个方法仅仅是参数类型不同，想办法合并他们
//T代表占位类型，可以是任何一种类型，
//a与b类型都是T,T只能是一种类型，所以a与b的类型一定要相同
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
swapTwoValues(&someStr, b: &anotherStr) //传入两个String类型
var someInt = 4
var anotherInt = 8
swapTwoValues(&someInt, b: &anotherInt)//传入两个Int类型
//swapTwoValues(&someStr, b: &anotherInt) //报错a和b类型不同
使用多个泛型类型参数(在"<>"内用","分隔)
func toBeDict<KeyType,ValueType>(inout a: KeyType, inout b: ValueType) {
Dictionary(dictionaryLiteral: (String(a), b))
}
toBeDict(&someStr,b: &someInt) //输出["I am A": 8]
泛型枚举
enum OptionalValue<T> {
case None
case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)
用泛型来建立一个栈
//栈和Array相似，一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop一个值出栈）
struct Stack<T> {
//创建一个名为items的属性，使用空的T类型值数组对其进行初始化
var items = [T]()
//指定一个包含一个参数名为item的push方法，该参数必须是T类型
mutating func push(item: T) {
items.append(item)
}
//指定一个pop方法的返回值，该返回值将是一个T类型值
mutating func pop() -> T {
return items.removeLast()
}
}
var stackOfStrings = Stack<String>() //一个String栈
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.pop() //"dos"
stackOfStrings.pop() //"uno"
泛型约束语法
第一种，泛型类型后面追加协议
//Equatable协议规定了T的类型一定能使用"=="和"!="
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in EnumerateSequence(array) {
if value == valueToFind {
return index
}
}
return nil
}
findIndex([0,2,3,1], valueToFind: 1)
第二种,使用where约束
在实际使用where前，谈一下typealias(关联类型)
/*
typealias是一种常用于协议的特殊泛型，它可以使协议适用于更多情况
常规的写法应该是typealias MyInt = Int。表示给Int取一个别名为MyInt。
单独写typealias ItemType 代表给任意类型取别名为ItemType
协议中的关联类型的实际类型是不需要指定的，直到该协议接受。
注：这里的typealias不是用于约束泛型，而是为了下面的where约束泛型而服务的
*/
protocol Container {
typealias ItemType
//对象必须可以通过append方法添加一个新item到容器里；
mutating func append(item: ItemType)
//对象必须可以使用count属性获取容器里items的数量，并返回一个Int值
var count: Int { get } //get代表只读属性
//对象必须可以通过容器的Int索引值下标可以检索到每一个item
subscript(i: Int) -> ItemType { get }
}
//注意，这里满足Container约束的对象是StackPro结构体，而不是T
struct StackPro<T>: Container {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
mutating func append(item: T) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> T {
return items[i]
}
}
var stackProOfStrings = StackPro<String>() //一个String栈
stackProOfStrings.push("uno")
stackProOfStrings.push("dos")
stackProOfStrings.count
扩展一个存在的类型为一指定关联类型(为了下面Array有ItemType这个属性)
//Array已经满足Container协议中的三个方法，其中的ItemType属性又是在运行时自动确定的类型，所以我们写一个空扩展就行了
extension Array: Container {}
//使用where约束
func allItemsMatch<
C1: Container, C2: Container
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
(someContainer: C1,_ anotherContainer: C2) -> Bool {
if someContainer.count != anotherContainer.count {
return false
}
for i in 0..<someContainer.count {
if someContainer[i] != anotherContainer[i] {
return false
}
}
return true
}
var stackProOfStrings2 = StackPro<String>()
stackProOfStrings2.push("uno")
stackProOfStrings2.push("dos")
stackProOfStrings2.push("tres")
var arrayOfStrings = ["uno", "dos", "tres"]
//按这么绕了一大圈之后arrayOfStrings和stackProOfStrings2这两个类型不同的对象可以比较了
if allItemsMatch(stackProOfStrings2, arrayOfStrings) {
print("All items match.") //输出 All items match
} else {
print("Not all items match.")
}
