//函数的定义
//形参默认是let，也只能是let

import Foundation
func pi() -> Double {
return 3.14
}
func sum(v1: Int, v2: Int) -> Int {
return v1+v2
}

//无返回值
func sayHello() -> Void {
print("Hello")
}
func sayHello1() -> () {
print("Hello")
}
func sayHello2() {
print("Hello")
}

//隐式返回 （Implicit Return）
//如果整个函数式一个单一表达式，那么函数会隐式返回这个表达式
func sum(v1: Int, v2: Int) {
v1+v2
}
print("sum is (sum(v1: 10, v2: 20))")

//返回元组：实现多值返回
func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
let sum = v1 + v2
return(sum, v1-v2, sum >> 1)
}
let result = calculate(v1: 10, v2: 20)
print(result.sum)
print(result.difference)
print(result.average)

//函数的文档注释
/// 求和【概述】
///
///将两个整数相加【更详细的描述】
///
/// - Parameter v1: 第一个整数
/// - Parameter v2: 第二个整数
/// - Returns: 2个整数的和
///
/// - Note: 传入2个整数即可【批注】
///
func sum2(v1: Int, v2: Int) ->Int { v1 + v2}
//更加详细的文档参考：https://swift.org/documentation/api-design-guidelines

//参数标签（Argument Label)
func goToWork (at time: String) {
print("this time is (time)")
}
goToWork(at: "8:20") //this time is 8:20

//可以使用下划线_ 省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
print(sum(10, 20)) //30

//默认参数值
//函数可以有默认值（Default Parameter Value）
func check(name: String = "nobody", age: Int, job: String = "none") {
print("name=(name), age=(age), job=(job)")
}
check(name: "Jack", age: 20, job: "Doctor") //name=Jack, age=20, job=Doctor
check(name: "Rose", age: 19) //name=Rose, age=19, job=none
check(age: 10, job: "Batman") //name=nobody, age=10, job=Batman
check(age: 15) //name=nobody, age=15, job=none

//C++的默认参数值有个限制：必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制
//但是再省略参数标签时，需要特别注意，避免出错
//这里的middle不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30) {}
test(middle:20)

//可变参数（Variadic Parameter）
func sum1(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
print("sum1 is (sum1(10, 20, 30, 40))"); // sum1 is 100

//一个函数最多只能有1个可变参数
//紧跟在可变参数后面的参数不能加省略参数标签 “”
func test( numbers: Int..., string: String, _ other: String) {}
test(10, 20, 30, string: "jack", "other")

/// - Parameters:
/// - items: Zero or more items to print. （可变参数）
/// - separator: A string to print between each item. The default is a single
/// space (" "). （分隔符，默认空格）
/// - terminator: The string to print after all items have been printed. The
/// default is a newline ("\n"). （结束符，默认换行符）
/// public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
print("1", "2", "3", separator:",") //1,2,3#
print("1", "2", "3", "4", "5", separator: "_") //1_2_3_4_5
print("my name is Jake.", terminator: "")
print("my age is 18.") //my name is Jake.my age is 18.

var number1 = 10
//函数参数默认都是let常量，声明为var也不行，不能时变量，不可以改
func add(_ num: Int) {
// num += 1 //这里回报错，先注释掉了
}
add(number1) //这仅仅是把 10 值传递给了add方法，和number1这个变量并没有关系

//输入输出参数（Int-Out Parameter)
//可以用inout定义一个输入输出参数：在函数内部修改外部实参的值，注意可变参数不能标记为inout
func add1(_ num: inout Int) {
num = 20
}
add1(&number1)
print(number1) //20

func swapValues(_ v1: inout Int, _ v2: inout Int) {
let tmp = v1
v1 = v2
v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)

//利用元组来实现交换值
func swapValues2(_ v1: inout Int, _ v2: inout Int) {
(v1, v2) = (v2, v1)
}

// 汇编中
// callq为调用方法,后面跟着函数方法地址，例如：callq 0x100000f60
// leaq用来传地址，例如：leaq 0x10da(%rip), %rdi 所代表的意思是把0x10da(%rip)这个地址值，传给%rdi寄存器

// movq $0x14, (%rdi) 汇编代码含义如下：
// 把20这个值，复制给（%rdi）所对应的内存空间
// (%rdi) 代表的意思是，找到rdi寄存器存储到地址值所对应的内存空间

var number = 10;
func test(_ num: inout Int) {
num = 20
}
test(&number) //本质上还是地址传递，把地址传给方法test，在函数内部把值赋值到内存地址，汇编代码为 leaq 开头
//test(number) //这种就是值传递，汇编代码为 movq 开头，例如：movq -0x30(%rbp), %rdi 所代表的意思是把%rbp减去-0x30结果的内存地址中的值，赋值给%rdi寄存器存储的内存地址所指向的内存。
print(number)

//inout参数不能有默认值
//inout参数的本质是地址传递（引用传递）
//inout参数只能传入可以被多次赋值的

//函数重载 （Function Overload）
//规则
//参数名相同
//参数个数不同 || 参数类型不同 || 参数标签不同
func sum1(v1: Int, v2: Int) -> Int {
v1 + v2
}

func sum1(v1: Int, v2: Int, v3: Int) -> Int {
v1 + v2 + v3
} //参数个数不同

func sum1(v1: Int, v2: Double) -> Double {
Double(v1) + v2
} //参数类型不同
func sum1(v1: Double, v2: Int) -> Double {
v1 + Double(v2)
} //参数类型不同

func sum1(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
} //参数标签不同
func sum1(a: Int, b: Int) -> Int {
a + b
} //参数标签不同

print(sum1(v1: 10, v2: 20)) //30
print(sum1(v1: 10, v2: 20, v3: 30)) //60
print(sum1(v1: 10, v2: 20.0)) //30.0
print(sum1(v1: 10.0, v2: 20)) //30.0
//print(sum1(10, 20)) 这种在新版swift中不可以了，有歧义报错
print(sum1(a:10, b:20)) //30

//函数重载注意点
//返回值类型与函数重载无关, 参数相同，参数类型相同，但是返回值不同，不构成重载
func sum3(v1: Int, v2: Int) -> Int {v1 + v2}
func sum3(v1: Int, v2: Int) {}
//sum3(v1:10, v2:20)

//默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在c++中回报错）
func sum4(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum4(v1: Int, v2: Int, v3: Int = 10) -> Int {
v1 + v2 + v3
}
//会调用sum(v1: Int, v2: Int)
print("sum4 (sum4(v1: 10, v2: 20))")

//可变参数，省略参数标签，函数重载一起使用产生二义性时，编译器有可能会报错
//func sum5(v1: Int, v2: Int) -> Int { //注销掉这个函数就可以编译通过
// v1 + v2
//}
func sum5(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
func sum5(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
sum5(10, 20)

//内联函数 （Inline Function）
//如果开启了编译器优化（Release模式默认会开启优化），编译器会编译时自动将某些函数变成内联函数
//将函数调用展开成函数体
//开启步骤：Build Setting -> Swift Compiler-Code Generation -> Optimization Level(优化等级)。 debug模式下默认不优化
//例如
func test(){
print("test")
}
//会把上述函数直接展开成如下, 减少函数调用开销，例如开辟栈空间，回收栈空间 等
print("test")

//有一些函数不会被内联：
// 1.函数体比较长
// 2.包含递归调用
// 3.包含动态派发 （例如多态调用类方法，在运行时才能确定调用方法，这种就不会被内联）
class Person {
func test() {}
}

//关键字 @inline(never) 永远不会被内联（即使开启了编译器优化）,
@inline(never) func test10() {
print("test")
}

//关键字 @inline(_always) 开启编译器优化后，即使代码会很长，也会被内联（递归调用函数，动态派发的函数除外）
//在Release模式下，编译器已经开启优化，会自动决定哪些函数需要内联，因此没必要使用 @inline
@inline(__always) func text11() {
print("test11")
}

class Student : Person {
override func test() {}
}

class Teacher : Person {
override func test() {}
}
var p: Person = Student();
p = Teacher();
p.test()

//函数类型
//每一个函数都是有类型的，函数类型由形式参数类型，返回值类型组成
func test2() {}
func sum2(a: Int, b: Int){ a+b }
// 定义变量
var fn: (Int, Int) -> Int = sum2
fn(2, 3) //5, 调用时不需要参数标签

//函数类型作为函数参数
func sum5test(v1: Int, v2: Int) -> Int {
v1 + v2
}
func difference1(v1: Int, v2: Int) -> Int {
v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: (mathFn(a,b))")
}
printResult(sum5test, 5, 2)
printResult(difference1, 5, 2)

//class Person2 {
// var age: Int = 0
// var fn: (_ a: Int, _ b: Int) -> Int {
// return a+b
// }
//}

//函数类型作为函数返回值
//返回值时函数类型的函数，叫做高阶函数（Higher-Order Function），例如下面的forward为高阶函数
func next(_ input: Int) -> Int {
input + 1
}
func previous(_ input: Int) -> Int {
input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int {
forward ? next : previous
}
print(forward(true)(3)) //4
print(forward(false)(3)) //2

//typealias
//typealias用来给类型起别名
typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64

//给元组类型起别名，Date代表右边的元组
typealias Date = (year: Int, month: Int, day: Int)
func test9(_ date: Date) {
print(date.0)
print(date.year)
}
test9((2011, 9, 10)) // 2011, 2011

//
typealias IntFn = (Int, Int) -> Int
func difference(v1: Int, v2: Int) -> Int {
v1 - v2
}
let fn1: IntFn = difference
print(fn1(20, 10)) //10

//要求参数时IntFn类型，difference是符合这种类型的，所以可以传入
func setFn(_ fn: IntFn) {}
setFn(difference)

//返回类型是IntFn
func getFn()-> IntFn { difference }

//按照Swift标准库的定义，Void就是空元组()
func testVoid() {}
func testVoid1() -> Void {}
func testVoid2() -> () {}

//按照Swift标准库的定义，Void就是空元组(), 下面是源码
public typealias Void = ()

//嵌套函数（Nested Function）
//将函数定义在函数内部
func forward1(_ forward: Bool) -> (Int) -> Int {
func next(_ input: Int) -> Int {
input + 1
}

func previous(_ input: Int) -> Int  {
    input - 1
}
return forward ? next : previous

}
forward1(true)(3) //4
forward1(false)(3) //2