兩個相同的網(wǎng)站對做優(yōu)化有幫助網(wǎng)絡(luò)推廣渠道
1、
Swift 枚舉
Swift 中使用 enum 關(guān)鍵詞來創(chuàng)建枚舉并且把它們的整個定義放在一對大括號內(nèi)：
enum enumname {// 枚舉定義放在這里
}
如下事例：
// 定義枚舉
enum DaysofaWeek {case Sundaycase Mondaycase TUESDAYcase WEDNESDAYcase THURSDAYcase FRIDAYcase Saturday
}var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
枚舉中定義的值（如?Sunday，Monday，……和Saturday）是這個枚舉的成員值（或成員）。case關(guān)鍵詞表示一行新的成員值將被定義。
注意： 和 C 和 Objective-C 不同，Swift 的枚舉成員在被創(chuàng)建時不會被賦予一個默認的整型值。在上面的
DaysofaWeek例子中，Sunday，Monday，……和Saturday不會隱式地賦值為0，1，……和6。相反，這些枚舉成員本身就有完備的值，這些值是已經(jīng)明確定義好的DaysofaWeek類型。
var weekDay = DaysofaWeek.THURSDAY
weekDay的類型可以在它被DaysofaWeek的一個可能值初始化時推斷出來。一旦weekDay被聲明為一個DaysofaWeek，你可以使用一個縮寫語法（.）將其設(shè)置為另一個DaysofaWeek的值：
var weekDay = .THURSDAY
當weekDay的類型已知時，再次為其賦值可以省略枚舉名。使用顯式類型的枚舉值可以讓代碼具有更好的可讀性。
枚舉可分為相關(guān)值與原始值。
相關(guān)值與原始值的區(qū)別
| 相關(guān)值 | 原始值 |
|---|---|
| 不同數(shù)據(jù)類型 | 相同數(shù)據(jù)類型 |
| 實例: enum {10,0.8,"Hello"} | 實例: enum {10,35,50} |
| 值的創(chuàng)建基于常量或變量? | 預先填充的值? |
| 相關(guān)值是當你在創(chuàng)建一個基于枚舉成員的新常量或變量時才會被設(shè)置，并且每次當你這么做得時候，它的值可以是不同的。? | 原始值始終是相同的 |
相關(guān)值
以下實例中我們定義一個名為 Student 的枚舉類型，它可以是 Name 的一個字符串（String），或者是 Mark 的一個相關(guān)值（Int，Int，Int）。
import Cocoaenum Student{case Name(String)case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Runoob")
var studMarks = Student.Mark(98,97,95)
switch studMarks {
case .Name(let studName):print("學生的名字是: \(studName)。")
case .Mark(let Mark1, let Mark2, let Mark3):print("學生的成績是: \(Mark1),\(Mark2),\(Mark3)。")
}
原始值
原始值可以是字符串，字符，或者任何整型值或浮點型值。每個原始值在它的枚舉聲明中必須是唯一的。
在原始值為整數(shù)的枚舉時，不需要顯式的為每一個成員賦值，Swift會自動為你賦值。
例如，當使用整數(shù)作為原始值時，隱式賦值的值依次遞增1。如果第一個值沒有被賦初值，將會被自動置為0。
import Cocoaenum Month: Int {case January = 1, February, March, April, May, June, July, August, September, October, November, December
}let yearMonth = Month.May.rawValue
print("數(shù)字月份為: \(yearMonth)。")
以上程序執(zhí)行輸出結(jié)果為：
數(shù)字月份為: 5。
2、
Swift 結(jié)構(gòu)體
Swift 結(jié)構(gòu)體是構(gòu)建代碼所用的一種通用且靈活的構(gòu)造體。
我們可以為結(jié)構(gòu)體定義屬性（常量、變量）和添加方法，從而擴展結(jié)構(gòu)體的功能。
與 C 和 Objective C 不同的是：
-
結(jié)構(gòu)體不需要包含實現(xiàn)文件和接口。?
-
結(jié)構(gòu)體允許我們創(chuàng)建一個單一文件，且系統(tǒng)會自動生成面向其它代碼的外部接口。?
結(jié)構(gòu)體總是通過被復制的方式在代碼中傳遞，因此它的值是不可修改的。
語法
我們通過關(guān)鍵字 struct 來定義結(jié)構(gòu)體：
struct nameStruct { Definition 1Definition 2……Definition N
}
我們可以通過結(jié)構(gòu)體名來訪問結(jié)構(gòu)體成員。
結(jié)構(gòu)體實例化使用?let?關(guān)鍵字：
結(jié)構(gòu)體應(yīng)用
在你的代碼中，你可以使用結(jié)構(gòu)體來定義你的自定義數(shù)據(jù)類型。
結(jié)構(gòu)體實例總是通過值傳遞來定義你的自定義數(shù)據(jù)類型。
按照通用的準則，當符合一條或多條以下條件時，請考慮構(gòu)建結(jié)構(gòu)體：
- 結(jié)構(gòu)體的主要目的是用來封裝少量相關(guān)簡單數(shù)據(jù)值。
- 有理由預計一個結(jié)構(gòu)體實例在賦值或傳遞時，封裝的數(shù)據(jù)將會被拷貝而不是被引用。
- 任何在結(jié)構(gòu)體中儲存的值類型屬性，也將會被拷貝，而不是被引用。
- 結(jié)構(gòu)體不需要去繼承另一個已存在類型的屬性或者行為。
舉例來說，以下情境中適合使用結(jié)構(gòu)體：
- 幾何形狀的大小，封裝一個
width屬性和height屬性，兩者均為Double類型。 - 一定范圍內(nèi)的路徑，封裝一個
start屬性和length屬性，兩者均為Int類型。 - 三維坐標系內(nèi)一點，封裝
x，y和z屬性，三者均為Double類型。
結(jié)構(gòu)體實例是通過值傳遞而不是通過引用傳遞。
3、
Swift 類
Swift 類是構(gòu)建代碼所用的一種通用且靈活的構(gòu)造體。
我們可以為類定義屬性（常量、變量）和方法。
與其他編程語言所不同的是，Swift 并不要求你為自定義類去創(chuàng)建獨立的接口和實現(xiàn)文件。你所要做的是在一個單一文件中定義一個類，系統(tǒng)會自動生成面向其它代碼的外部接口。
類和結(jié)構(gòu)體對比
Swift 中類和結(jié)構(gòu)體有很多共同點。共同處在于：
- 定義屬性用于存儲值
- 定義方法用于提供功能
- 定義附屬腳本用于訪問值
- 定義構(gòu)造器用于生成初始化值
- 通過擴展以增加默認實現(xiàn)的功能
- 符合協(xié)議以對某類提供標準功能
與結(jié)構(gòu)體相比，類還有如下的附加功能：
- 繼承允許一個類繼承另一個類的特征
- 類型轉(zhuǎn)換允許在運行時檢查和解釋一個類實例的類型
- 解構(gòu)器允許一個類實例釋放任何其所被分配的資源
- 引用計數(shù)允許對一個類的多次引用
語法:
class classname {Definition 1Definition 2……Definition N
}
類定義
class student{var studname: Stringvar mark: Int var mark2: Int
}
實例化類：
let studrecord = student()
作為引用類型訪問類屬性
類的屬性可以通過?.?來訪問。格式為：實例化類名.屬性名：
恒等運算符
因為類是引用類型，有可能有多個常量和變量在后臺同時引用某一個類實例。
為了能夠判定兩個常量或者變量是否引用同一個類實例，Swift 內(nèi)建了兩個恒等運算符：
| 恒等運算符 | 不恒等運算符 |
|---|---|
| 運算符為：=== | 運算符為：!== |
| 如果兩個常量或者變量引用同一個類實例則返回 true | 如果兩個常量或者變量引用不同一個類實例則返回 true |
實例
import Cocoaclass SampleClass: Equatable {let myProperty: Stringinit(s: String) {myProperty = s}
}
func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {return lhs.myProperty == rhs.myProperty
}let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")if spClass1 === spClass2 {// falseprint("引用相同的類實例 \(spClass1)")
}if spClass1 !== spClass2 {// trueprint("引用不相同的類實例 \(spClass2)")
}
以上程序執(zhí)行輸出結(jié)果為：
引用不相同的類實例 SampleClass
4、
Swift 屬性
Swift 屬性將值跟特定的類、結(jié)構(gòu)或枚舉關(guān)聯(lián)。
屬性可分為存儲屬性和計算屬性:
| 存儲屬性 | 計算屬性 |
|---|---|
| 存儲常量或變量作為實例的一部分 | 計算（而不是存儲）一個值? |
| 用于類和結(jié)構(gòu)體 | 用于類、結(jié)構(gòu)體和枚舉 |
存儲屬性和計算屬性通常用于特定類型的實例。
屬性也可以直接用于類型本身，這種屬性稱為類型屬性。
另外，還可以定義屬性觀察器來監(jiān)控屬性值的變化，以此來觸發(fā)一個自定義的操作。屬性觀察器可以添加到自己寫的存儲屬性上，也可以添加到從父類繼承的屬性上。
存儲屬性
簡單來說，一個存儲屬性就是存儲在特定類或結(jié)構(gòu)體的實例里的一個常量或變量。
存儲屬性可以是變量存儲屬性（用關(guān)鍵字var定義），也可以是常量存儲屬性（用關(guān)鍵字let定義）。
-
可以在定義存儲屬性的時候指定默認值
-
也可以在構(gòu)造過程中設(shè)置或修改存儲屬性的值，甚至修改常量存儲屬性的值
-
延遲存儲屬性
延遲存儲屬性是指當?shù)谝淮伪徽{(diào)用的時候才會計算其初始值的屬性。
在屬性聲明前使用?lazy?來標示一個延遲存儲屬性。
注意：
必須將延遲存儲屬性聲明成變量（使用var關(guān)鍵字），因為屬性的值在實例構(gòu)造完成之前可能無法得到。而常量屬性在構(gòu)造過程完成之前必須要有初始值，因此無法聲明成延遲屬性。?延遲存儲屬性一般用于：
-
延遲對象的創(chuàng)建。
-
當屬性的值依賴于其他未知類
-
實例化變量
如果您有過 Objective-C 經(jīng)驗，應(yīng)該知道Objective-C 為類實例存儲值和引用提供兩種方法。對于屬性來說，也可以使用實例變量作為屬性值的后端存儲。
Swift 編程語言中把這些理論統(tǒng)一用屬性來實現(xiàn)。Swift 中的屬性沒有對應(yīng)的實例變量，屬性的后端存儲也無法直接訪問。這就避免了不同場景下訪問方式的困擾，同時也將屬性的定義簡化成一個語句。
一個類型中屬性的全部信息——包括命名、類型和內(nèi)存管理特征——都在唯一一個地方（類型定義中）定義。
計算屬性
除存儲屬性外，類、結(jié)構(gòu)體和枚舉可以定義計算屬性，計算屬性不直接存儲值，而是提供一個 getter 來獲取值，一個可選的 setter 來間接設(shè)置其他屬性或變量的值。
import Cocoaclass sample {var no1 = 0.0, no2 = 0.0var length = 300.0, breadth = 150.0var middle: (Double, Double) {get{return (length / 2, breadth / 2)}set(axis){no1 = axis.0 - (length / 2)no2 = axis.1 - (breadth / 2)}} }var result = sample() print(result.middle) result.middle = (0.0, 10.0)print(result.no1) print(result.no2)以上程序執(zhí)行輸出結(jié)果為：
(150.0, 75.0) -150.0 -65.0
如果計算屬性的 setter 沒有定義表示新值的參數(shù)名，則可以使用默認名稱 newValue。
只讀計算屬性
只有 getter 沒有 setter 的計算屬性就是只讀計算屬性。
只讀計算屬性總是返回一個值，可以通過點(.)運算符訪問，但不能設(shè)置新的值。
-
注意：
必須使用
var關(guān)鍵字定義計算屬性，包括只讀計算屬性，因為它們的值不是固定的。let關(guān)鍵字只用來聲明常量屬性，表示初始化后再也無法修改的值。 -
屬性觀察器
屬性觀察器監(jiān)控和響應(yīng)屬性值的變化，每次屬性被設(shè)置值的時候都會調(diào)用屬性觀察器，甚至新的值和現(xiàn)在的值相同的時候也不例外。
可以為除了延遲存儲屬性之外的其他存儲屬性添加屬性觀察器，也可以通過重載屬性的方式為繼承的屬性（包括存儲屬性和計算屬性）添加屬性觀察器。
注意：
不需要為無法重載的計算屬性添加屬性觀察器，因為可以通過 setter 直接監(jiān)控和響應(yīng)值的變化。?可以為屬性添加如下的一個或全部觀察器：
willSet在設(shè)置新的值之前調(diào)用didSet在新的值被設(shè)置之后立即調(diào)用- willSet和didSet觀察器在屬性初始化過程中不會被調(diào)用
import Cocoaclass Samplepgm {var counter: Int = 0{willSet(newTotal){print("計數(shù)器: \(newTotal)")}didSet{if counter > oldValue {print("新增數(shù) \(counter - oldValue)")}}} } let NewCounter = Samplepgm() NewCounter.counter = 100 NewCounter.counter = 800以上程序執(zhí)行輸出結(jié)果為：
計數(shù)器: 100 新增數(shù) 100 計數(shù)器: 800 新增數(shù) 700
全局變量和局部變量
計算屬性和屬性觀察器所描述的模式也可以用于全局變量和局部變量。
| 局部變量 | 全局變量 |
|---|---|
| 在函數(shù)、方法或閉包內(nèi)部定義的變量。 | 函數(shù)、方法、閉包或任何類型之外定義的變量。 |
| 用于存儲和檢索值。 | 用于存儲和檢索值。 |
| 存儲屬性用于獲取和設(shè)置值。 | 存儲屬性用于獲取和設(shè)置值。 |
| 也用于計算屬性。 | 也用于計算屬性。 |
類型屬性
類型屬性是作為類型定義的一部分寫在類型最外層的花括號（{}）內(nèi)。
使用關(guān)鍵字 static 來定義值類型的類型屬性，關(guān)鍵字 class 來為類定義類型屬性。
struct Structname { static var storedTypeProperty = " "static var computedTypeProperty: Int {// 這里返回一個 Int 值}
}enum Enumname { static var storedTypeProperty = " "static var computedTypeProperty: Int {// 這里返回一個 Int 值}
}class Classname { class var computedTypeProperty: Int {// 這里返回一個 Int 值}
}
注意：
例子中的計算型類型屬性是只讀的，但也可以定義可讀可寫的計算型類型屬性，跟實例計算屬性的語法類似。
獲取和設(shè)置類型屬性的值
類似于實例的屬性，類型屬性的訪問也是通過點運算符(.)來進行。但是，類型屬性是通過類型本身來獲取和設(shè)置，而不是通過實例。實例如下：
import Cocoastruct StudMarks {static let markCount = 97static var totalCount = 0var InternalMarks: Int = 0 {didSet {if InternalMarks > StudMarks.markCount {InternalMarks = StudMarks.markCount}if InternalMarks > StudMarks.totalCount {StudMarks.totalCount = InternalMarks}}}
}var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks) stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)
以上程序執(zhí)行輸出結(jié)果為：
97 87
5、
Swift 方法
Swift 方法是與某些特定類型相關(guān)聯(lián)的函數(shù)
在 Objective-C 中，類是唯一能定義方法的類型。但在 Swift 中，你不僅能選擇是否要定義一個類/結(jié)構(gòu)體/枚舉，還能靈活的在你創(chuàng)建的類型（類/結(jié)構(gòu)體/枚舉）上定義方法。
實例方法
在 Swift 語言中，實例方法是屬于某個特定類、結(jié)構(gòu)體或者枚舉類型實例的方法。
實例方法提供以下方法：
-
可以訪問和修改實例屬性
-
提供與實例目的相關(guān)的功能
實例方法要寫在它所屬的類型的前后大括號({})之間。
實例方法能夠隱式訪問它所屬類型的所有的其他實例方法和屬性。
實例方法只能被它所屬的類的某個特定實例調(diào)用。
實例方法不能脫離于現(xiàn)存的實例而被調(diào)用。
語法
func funcname(Parameters) -> returntype
{Statement1Statement2……Statement Nreturn parameters
}
方法的局部參數(shù)名稱和外部參數(shù)名稱
Swift 函數(shù)參數(shù)可以同時有一個局部名稱（在函數(shù)體內(nèi)部使用）和一個外部名稱（在調(diào)用函數(shù)時使用
Swift 中的方法和 Objective-C 中的方法極其相似。像在 Objective-C 中一樣，Swift 中方法的名稱通常用一個介詞指向方法的第一個參數(shù)，比如：with，for，by等等。
Swift 默認僅給方法的第一個參數(shù)名稱一個局部參數(shù)名稱;默認同時給第二個和后續(xù)的參數(shù)名稱為全局參數(shù)名稱。
以下實例中 'no1' 在swift中聲明為局部參數(shù)名稱。'no2' 用于全局的聲明并通過外部程序訪問。
import Cocoaclass division {var count: Int = 0func incrementBy(no1: Int, no2: Int) {count = no1 / no2print(count)}
}let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)
是否提供外部名稱設(shè)置
我們強制在第一個參數(shù)添加外部名稱把這個局部名稱當作外部名稱使用（Swift 2.0前是使用 # 號）。
相反，我們呢也可以使用下劃線（_）設(shè)置第二個及后續(xù)的參數(shù)不提供一個外部名稱。
import Cocoaclass multiplication {var count: Int = 0func incrementBy(first no1: Int, no2: Int) {count = no1 * no2print(count)}
}
let counter = multiplication() counter.incrementBy(first: 800, no2: 3) counter.incrementBy(first: 100, no2: 5) counter.incrementBy(first: 15000, no2: 3)
self 屬性
類型的每一個實例都有一個隱含屬性叫做self，self 完全等同于該實例本身。
你可以在一個實例的實例方法中使用這個隱含的self屬性來引用當前實例。
在實例方法中修改值類型
Swift 語言中結(jié)構(gòu)體和枚舉是值類型。一般情況下，值類型的屬性不能在它的實例方法中被修改。
但是，如果你確實需要在某個具體的方法中修改結(jié)構(gòu)體或者枚舉的屬性，你可以選擇變異(mutating)這個方法，然后方法就可以從方法內(nèi)部改變它的屬性；并且它做的任何改變在方法結(jié)束時還會保留在原始結(jié)構(gòu)中。
方法還可以給它隱含的self屬性賦值一個全新的實例，這個新實例在方法結(jié)束后將替換原來的實例。
import Cocoastruct area {var length = 1var breadth = 1func area() -> Int {return length * breadth} mutating func scaleBy(res: Int) {length *= resbreadth *= resprint(length)print(breadth)}
}var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)
以上程序執(zhí)行輸出結(jié)果為：
9 15 270 450 81000 135000
在可變方法中給 self 賦值
可變方法能夠賦給隱含屬性 self 一個全新的實例。
import Cocoastruct area {var length = 1var breadth = 1func area() -> Int {return length * breadth}mutating func scaleBy(res: Int) {self.length *= resself.breadth *= resprint(length)print(breadth)}
}
var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)
以上程序執(zhí)行輸出結(jié)果為：
39 65
類型方法?
實例方法是被類型的某個實例調(diào)用的方法，你也可以定義類型本身調(diào)用的方法，這種方法就叫做類型方法。
聲明結(jié)構(gòu)體和枚舉的類型方法，在方法的func關(guān)鍵字之前加上關(guān)鍵字static。類可能會用關(guān)鍵字class來允許子類重寫父類的實現(xiàn)方法。
類型方法和實例方法一樣用點號(.)語法調(diào)用。
import Cocoaclass Math
{class func abs(number: Int) -> Int{if number < 0{return (-number)}else{return number}}
}struct absno
{static func abs(number: Int) -> Int{if number < 0{return (-number)}else{return number}}
}let no = Math.abs(number: -35)
let num = absno.abs(number: -5)print(no)
print(num)
以上程序執(zhí)行輸出結(jié)果為：
35 5
6、
Swift 下標腳本
下標腳本 可以定義在類（Class）、結(jié)構(gòu)體（structure）和枚舉（enumeration）這些目標中，可以認為是訪問對象、集合或序列的快捷方式，不需要再調(diào)用實例的特定的賦值和訪問方法。
舉例來說，用下標腳本訪問一個數(shù)組(Array)實例中的元素可以這樣寫 someArray[index] ，訪問字典(Dictionary)實例中的元素可以這樣寫 someDictionary[key]。
對于同一個目標可以定義多個下標腳本，通過索引值類型的不同來進行重載，而且索引值的個數(shù)可以是多個。
下標腳本語法及應(yīng)用
語法
下標腳本允許你通過在實例后面的方括號中傳入一個或者多個的索引值來對實例進行訪問和賦值。
語法類似于實例方法和計算型屬性的混合。
與定義實例方法類似，定義下標腳本使用subscript關(guān)鍵字，顯式聲明入?yún)?#xff08;一個或多個）和返回類型。
與實例方法不同的是下標腳本可以設(shè)定為讀寫或只讀。這種方式又有點像計算型屬性的getter和setter：
subscript(index: Int) -> Int {get {// 用于下標腳本值的聲明}set(newValue) {// 執(zhí)行賦值操作}
}
實例 1
import Cocoastruct subexample {let decrementer: Intsubscript(index: Int) -> Int {return decrementer / index}
}
let division = subexample(decrementer: 100)print("100 除以 9 等于 \(division[9])")
print("100 除以 2 等于 \(division[2])")
print("100 除以 3 等于 \(division[3])")
print("100 除以 5 等于 \(division[5])")
print("100 除以 7 等于 \(division[7])")
以上程序執(zhí)行輸出結(jié)果為：
100 除以 9 等于 11 100 除以 2 等于 50 100 除以 3 等于 33 100 除以 5 等于 20 100 除以 7 等于 14
在上例中，通過 subexample 結(jié)構(gòu)體創(chuàng)建了一個除法運算的實例。數(shù)值 100 作為結(jié)構(gòu)體構(gòu)造函數(shù)傳入?yún)?shù)初始化實例成員 decrementer。
你可以通過下標腳本來得到結(jié)果，比如 division[2] 即為 100 除以 2。
實例 2
import Cocoaclass daysofaweek {private var days = ["Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "saturday"]subscript(index: Int) -> String {get {return days[index] // 聲明下標腳本的值}set(newValue) {self.days[index] = newValue // 執(zhí)行賦值操作}}
}
var p = daysofaweek()print(p[0])
print(p[1])
print(p[2])
print(p[3])
以上程序執(zhí)行輸出結(jié)果為：
Sunday Monday Tuesday Wednesday
用法
根據(jù)使用場景不同下標腳本也具有不同的含義。
通常下標腳本是用來訪問集合（collection），列表（list）或序列（sequence）中元素的快捷方式。
你可以在你自己特定的類或結(jié)構(gòu)體中自由的實現(xiàn)下標腳本來提供合適的功能。
例如，Swift 的字典（Dictionary）實現(xiàn)了通過下標腳本對其實例中存放的值進行存取操作。在下標腳本中使用和字典索引相同類型的值，并且把一個字典值類型的值賦值給這個下標腳來為字典設(shè)值：
import Cocoavar numberOfLegs = ["spider": 8, "ant": 6, "cat": 4] numberOfLegs["bird"] = 2print(numberOfLegs)
以上程序執(zhí)行輸出結(jié)果為：
["ant": 6, "bird": 2, "cat": 4, "spider": 8]
上例定義一個名為numberOfLegs的變量并用一個字典字面量初始化出了包含三對鍵值的字典實例。numberOfLegs的字典存放值類型推斷為Dictionary。字典實例創(chuàng)建完成之后通過下標腳本的方式將整型值2賦值到字典實例的索引為bird的位置中。
import Cocoastruct Matrix {let rows: Int, columns: Intvar print: [Double]init(rows: Int, columns: Int) {self.rows = rowsself.columns = columnsprint = Array(repeating: 0.0, count: rows * columns)}subscript(row: Int, column: Int) -> Double {get {return print[(row * columns) + column]}set {print[(row * columns) + column] = newValue}}
}
// 創(chuàng)建了一個新的 3 行 3 列的Matrix實例
var mat = Matrix(rows: 3, columns: 3)// 通過下標腳本設(shè)置值
mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0// 通過下標腳本獲取值
print("\(mat[0,0])")
print("\(mat[0,1])")
print("\(mat[1,0])")
print("\(mat[1,1])")
以上程序執(zhí)行輸出結(jié)果為：
1.0 2.0 3.0 5.0
Matrix 結(jié)構(gòu)體提供了一個兩個傳入?yún)?shù)的構(gòu)造方法，兩個參數(shù)分別是rows和columns，創(chuàng)建了一個足夠容納rows * columns個數(shù)的Double類型數(shù)組。為了存儲，將數(shù)組的大小和數(shù)組每個元素初始值0.0。
你可以通過傳入合適的row和column的數(shù)量來構(gòu)造一個新的Matrix實例。