c语言控制流实验报告,Flow Control(控制流)

// 控制流

// “包括可以多次执行任务的while循环，基于特定条件选择执行不同代码分支的if、guard和switch语句，还有控制流程跳转到其他代码位置的break和continue语句。”

//“Swift 还提供了for-in循环，用来更简单地遍历数组(array)，字典(dictionary)，区间(range)，字符串(string)和其他序列类型。”

//1. for-in

// for-in可以遍历collection中的所有元素，数组或者字典都可以遍历。

for index in 1...5{

print("index is \(index)")

}

//“如果你不需要区间序列内每一项的值，你可以使用下划线(_)替代变量名来忽略这个值”

for _ in 1...5{

print("不需要值")

}

//2. while循环

// “while循环会一直运行一段语句直到条件变成false。 这类循环适合使用在第一次迭代前，迭代次数未知的情况下

//“while循环，每次在循环开始时计算条件是否符合；

//repeat-while循环，每次在循环结束时计算条件是否符合，会至少执行一次。

//2.1: “while循环从计算一个条件开始。如果条件为true，会重复运行一段语句，直到条件变为false。”

var i = 1

while i<5 {

i+=1

}

//2.2:“while循环的另外一种形式是repeat-while，它和while的区别是在判断循环条件之前，先执行一次循环的代码块。然后重复循环直到条件为false。”

//“Swift语言的repeat-while循环和其他语言中的do-while循环是类似的”

repeat {

i+=1

}while i<10

//3. 条件语句

//3.1: “if语句最简单的形式就是只包含一个条件，只有该条件为true时，才执行相关代码”

if i>5 {

print("jack")

}

//“if语句允许二选一执行，叫做else从句”

if i<5 {

print("rose")

}else{

print("jack")

}

//“多个if语句链接在一起，来实现更多分支”

if i<5 {

print("rose")

}else if i<8 {

print("rose")

}else{

print("jack")

}

//“当不需要完整判断情况的时候，最后的else语句是可选的”

if i < 5 {

print("rose")

}else if i < 8 {

print("rose")

}

//3.2: “switch语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式，switch语句会执行对应的代码。当有可能的情况较多时，通常用switch语句替换if语句”

//“switch语句由多个 case 构成，每个由case关键字开始。为了匹配某些更特定的值，Swift 提供了几种方法来进行更复杂的模式匹配，这些模式将在本节的稍后部分提到”

//“switch语句必须是完备的。这就是说，每一个可能的值都必须至少有一个 case 分支与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认(default)分支来涵盖其它所有没有对应的值，这个默认分支必须在switch语句的最后面。”

let someCharacter: Character = "z"

switch someCharacter {

case "a":

print("the first leter of the alphabet")

case "z":

print("the last letter of the alphabet")

default:

print("some other character")

}

// 不存在隐式的贯穿

//“与 C 和 Objective-C 中的switch语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用break语句”

//注意：虽然在Swift中break不是必须的，但你依然可以在 case 分支中的代码执行完毕前使用break跳出”

//“每一个 case 分支都必须包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的：”

//let anotherCharacter: Character = "a"

//switch anotherCharacter {

//case "a":

//case "A":

// print("letter A")

//default:

// print("Not the letter A")

//}

//“不像 C 语言里的switch语句，在 Swift 中，switch语句不会一起匹配"a"和"A"。相反的，上面的代码会引起编译期错误：case "a": 不包含任何可执行语句”

//“可以将这个两个值组合成一个复合匹配，并且用逗号分开：”

let anotherCharacter: Character = "a"

switch anotherCharacter {

case "a","A":

print("letter a")

default:

print("no letter a")

}

//区间匹配

let approximateCount = 62

let countedThings = "moons orbiting Saturn"

var naturalCount : String

switch approximateCount {

case 0 :

naturalCount = "no"

case 1..<5 :

naturalCount = "a few"

case 5..<12 :

naturalCount = "several"

case 12..<100 :

naturalCount = "dozens of"

default:

naturalCount = "many"

}

print(naturalCount)

//switch与元组

//“我们可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线(_)来匹配所有可能的值”

let somePoint = (1,1)

switch somePoint {

case (0,0):

print("0,0 is at the origin")

case (_,0):

print("somePoint,0 is on the x-axis")

case (0,_):

print("0,somePoint is on the y-axis")

case (-2...2,-2...2):

print("\(somePoint.0,somePoint.1) is inside of the box")

default:

print("is out side the box")

}

//“不像 C 语言，Swift 允许多个 case 匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有四个 case。但是，如果存在多个匹配，那么只会执行第一个被匹配到的 case 分支。

//switch与值绑定

//“case 分支允许将匹配的值绑定到一个临时的常量或变量，并且在case分支体内使用 —— 这种行为被称为值绑定(value binding)，因为匹配的值在case分支体内，与临时的常量或变量绑定”

let anotherPoint = (2,2)

switch anotherPoint {

case (let x,0):

print("on the x-axis with an x value of \(x)")

case (0,let y):

print("on the y-axis with an y value of \(y)")

case let (x,y):

print("some else at \(x,y)")

}

//“这个switch语句不包含默认分支。这是因为最后一个 case ——case let(x, y)声明了一个可以匹配余下所有值的元组。这使得switch语句已经完备了，因此不需要再书写默认分支。”

//switch与where

//“case 分支的模式可以使用where语句来判断额外的条件”

let yetAnothePoint = (1,-1)

switch yetAnothePoint {

case let (x,y) where x == y:

print("\(x,y) is on the line x==y")

case let (x,y) where x == -y:

print("\(x,y) is on the line x==-y")

case let (x,y):

print("\(x,y) is just some arbitrary point")

}

//switch与复合匹配

//“当多个条件可以使用同一种方法来处理时，可以将这几种可能放在同一个case后面，并且用逗号隔开。当case后面的任意一种模式匹配的时候，这条分支就会被匹配。并且，如果匹配列表过长，还可以分行书写”

let myCharacter: Character = "e"

switch myCharacter {

case "a","e","i","o","u":

print("\(someCharacter) is a vowel")

case "b","c","d","f","g","h","i","j",

"k","l" :

print("\(someCharacter) is a consonant")

default:

print("\(someCharacter) is not vowel or a consonant")

}

//“复合匹配同样可以包含值绑定。复合匹配里所有的匹配模式，都必须包含相同的值绑定。并且每一个绑定都必须获取到相同类型的值。这保证了，无论复合匹配中的哪个模式发生了匹配，分支体内的代码，都能获取到绑定的值，并且绑定的值都有一样的类型”

let stillAnotherPoint = (9,0)

switch stillAnotherPoint {

case (let distance,0),(0,let distance):

print("On an axis , \(distance) from the origin")

default:

print("not on an axis")

}

//4. 控制转移语句 ***

//“控制转移语句改变你代码的执行顺序，通过它可以实现代码的跳转。Swift 有五种控制转移语句：

/* continue

break

fallthrough

return

throw

*/

//4.1:“continue语句告诉一个循环体立刻停止本次循环，重新开始下次循环。就好像在说“本次循环我已经执行完了”，但是并不会离开整个循环体。”

let puzzleInput = "great minds think alike"

var puzzleOutput = ""

for character in puzzleInput.characters {

switch character {

case "a","e","i","o","u"," ":

continue

default:

puzzleOutput.append(character)

}

}

print(puzzleOutput)

//4.2:“break语句会立刻结束整个控制流的执行。当你想要更早的结束一个switch代码块或者一个循环体时，你都可以使用break语句。”

//“循环语句中的 break,当在一个循环体中使用break时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(})后的第一行代码。不会再有本次循环的代码被执行，也不会再有下次的循环产生。”

for i in 1..<5 {

print(i)

if i>3 {

break

}

}

//“Switch 语句中的 break,当在一个switch代码块中使用break时，会立即中断该switch代码块的执行，并且跳转到表示switch代码块结束的大括号(})后的第一行代码”

//“被用来匹配或者忽略一个或多个分支。因为 Swift 的switch需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上break语句。当那个分支被匹配到时，分支内的break语句立即结束switch代码块”

let numberSymbol: Character = "二"

var possibleIntegerValue : Int?

switch numberSymbol {

case "1","一","n":

possibleIntegerValue = 1

case "2","二","e","n":

possibleIntegerValue = 2

case "3","s","三","j":

break

default:

break

}

if let integerValue = possibleIntegerValue {

print("the integer value of \(numberSymbol) is \(integerValue) ")

}else{

print("an integer value could not be found")

}

//“在上面的例子中，想要把Character所有的的可能性都枚举出来是不现实的，所以使用default分支来包含所有上面没有匹配到字符的情况”

//4.3:贯穿 “Swift中的switch不会从上一个 case 分支落入到下一个 case 分支中。只要第一个匹配到的 case 分支完成了它需要执行的语句，整个switch代码块完成了它的执行”“相比之下，C 语言要求你显式地插入break语句到每个 case 分支的末尾来阻止自动落入到下一个 case 分支中”

//“如果你确实需要 C 风格的贯穿的特性，你可以在每个需要该特性的 case 分支中使用fallthrough关键字”

let integerToDescribe = 5

var description = "the number \(integerToDescribe) is "

switch integerToDescribe {

case 2,3,5,7,11,13,17,19:

description += "a prime number, and also "

fallthrough

default:

description += "an integer"

}

print(description) //the number 5 is a prime number, and also an integer

//“使用fallthrough关键字来“贯穿”到default分支中”

//注意：fallthrough关键字不会检查它下一个将会落入执行的 case 中的匹配条件。fallthrough简单地使代码继续连接到下一个 case 中的代码，这和 C 语言标准中的switch语句特性是一样的。

//4.4 带标签的语句

//“在 Swift 中，你可以在循环体和条件语句中嵌套循环体和条件语句来创造复杂的控制流结构。并且，循环体和条件语句都可以使用break语句来提前结束整个代码块。因此，显式地指明break语句想要终止的是哪个循环体或者条件语句，会很有用。类似地，如果你有许多嵌套的循环体，显式指明continue语句想要影响哪一个循环体也会非常有用。”

//“你可以使用标签(statement label)来标记一个循环体或者条件语句，对于一个条件语句，你可以使用break加标签的方式，来结束这个被标记的语句。对于一个循环语句，你可以使用break或者continue加标签，来结束或者继续这条被标记语句的执行”

for i in 1...10 {

for j in 1...10 {

if j>2 {

print("i:\(i),j:\(j)")

break //影响内循环

}

}

if i>4 {

print("外循环i:\(i)")

break // 影响外循环

}

}

outLoop: for i in 1...10 {

insideLoop: for j in 1...10 {

if j>2 {

print("insieLoop: i:\(i),j:\(j)")

break insideLoop

}

}

if i>4 {

print("outLoop: i:\(i)")

break outLoop

}

}

//使用循环标签会让层级更明显。

//5. 提前退出

//“像if语句一样，guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时，以执行guard语句后的代码。不同于if语句，一个guard语句总是有一个else从句，如果条件不为真则执行else从句中的代码”

func greet(_ peason : [ String : String ] ){

guard let name = peason["name"] else {

return

}

print("hello \(name)")

guard let location = peason["location"] else {

print("i hope the weather is nice in near you")

return

}

print("i hope the weather is nice in \(location)")

}

greet(["name":"jack"])

//hello jack

//i hope the weather is nice in near you

greet(["name":"rose","location":"Cupertino"])

//hello rose

//i hope the weather is nice in Cupertino

//“如果guard语句的条件被满足，则继续执行guard语句大括号 后 的代码。将变量或者常量的可选绑定作为guard语句的条件，都可以保护guard语句后面的代码。“如果条件不被满足，在else分支上的代码就会被执行。这个分支必须转移控制以退出guard语句出现的代码段”“它可以用控制转移语句如return,break,continue或者throw做这件事，或者调用一个不返回的方法或函数，例如fatalError()”

//“相比于可以实现同样功能的if语句，按需使用guard语句会提升我们代码的可读性。它可以使你的代码连贯的被执行而不需要将它包在else块中，它可以使你在紧邻条件判断的地方，处理违规的情况。”

//guard蛮好用的。

//6. 检测API的可用性

//“Swift内置支持检查 API 可用性，这可以确保我们不会在当前部署机器上，不小心地使用了不可用的API。”

if #available(iOS 10,macOS 10.12, watchOS 1.0,tvOS 1.0,*){

print("API可用，语句将执行")

}else{

print("API不可用，语句不会执行")

}