swift 5.0 函数及其底层实现

随着swift语言的不断发展,越来越来趋于稳定化。现在也有很多公司使用swift来开发新的App,那么不会swift开发的iOS开发者在竞争中还是很弱势的,所有学习swift是大势所趋。本系列文章根据以往的学习积累和项目经验,从基础到原理详细说说swift的这点事儿,不喜勿喷,交流指正请加微信。
WeChatdfdb8bfa7f0a84545d010ef18af70a98.png
一. 函数的定义
有返回值
    func text() -> Double {
        return 3.1415926
    }
    func sum(v1: Int,v2: Int) -> Int {
        return v1+v2;
    }
  // 调用
    sum(v1: 10, v2: 20)

形参默认是let,也只能是let

无返回值
    // 无返回值
    func sayHello() -> Void {
        print("Hello")
    }
返回元组:实现多返回值
 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: 20, v2: 10)
    result.sum // 30
    result.difference // 10
    result.average // 15
二. 参数标签
修改参数标签
    func goToWork(at time: String) {
        print("this time is \(time)")
    }
    goToWork(at: "08:00")
    // this time is 08:00
使用下划线 _ 省略参数标签
    func sum(_ v1:Int, _ v2: Int) -> Int {
        return v1 + v2
    }
    sum(10, 20)
三. 默认参数值
设置参数默认值
    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: 18) // name=Rose, age=18, job=none
    check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman
    check(age: 15) // name=nobody, age=15, job=none

注意: C++的默认参数值有个限制:必须从右往左设置。由于Swift拥有参数标签,因此并没有此类限制 n 但是在省略参数标签时,需要特别注意,避免出错。

middle
    // 这里的middle不可以省略参数标签
    func test(_ first: Int = 10, middle: Int, _ last: Int = 30) { }
    test(middle: 20)
四:可变参数
    func sum(_ numbers: Int...) -> Int {
        var total = 0
        for number in numbers {
            total += number
        }
        return total
    }
    sum(10, 20, 30, 40) // 100

一个函数最多只能有1个可变参数
紧跟在可变参数后面的参数不能省略参数标签

    // 参数string不能省略标签
    func test(_ numbers: Int..., string: String, _ other: String) { }
    test(10, 20, 30, string: "Jack", "Rose")
五. 输入输出参数
可以用inout定义一个输入输出参数:可以在函数内部修改外部实参的值
 var number = 10
 func test(_ num: Int) {
     num = 20
 }

 test(number)
原理分析:
swapValues(&num1, &num2) 函数调用传递的是地址传递还是值传递,inout 这个函数内部是怎么实现的呢?打上断点,汇编代码如下:
地址传递分析
点击下一步进入test函数内部
test函数内部
总结: 输入输出函数底层其实就是地址传递,将外部number的地址传给函数,然后再给number进行赋值。
为了更好地验证这个问题,将代码做以下修改
var number = 10
 
 func test(_ num: Int) {
 
 }
 
 test(number)
然后将汇编代码进行对比以下
var number = 10
 
 func test(_ num: Int) {
 
 }
 
 test(number)
 
 0x100000f5e <+78>: movq   -0x30(%rbp), %rdi
 0x100000f62 <+82>: callq  0x100000f70               ; TestSwift.test(Swift.Int) -> () at main.swift:24
 
 var number = 10
 
 func test(_ num: inout Int) {
 
 }
 
 test(&number)
 
 0x100000f47 <+55>: leaq   0x10ca(%rip), %rdi        ; TestSwift.number : Swift.Int
 0x100000f4e <+62>: callq  0x100000f70               ; TestSwift.test(inout Swift.Int) -> () at main.swift:24

可以看到正常的传值函数都是movq,值传递。input 是leaq传递,地址传递。movq就是通过取件码找快递,而leaq就是找到取件码

注意点:

1. 可变参数不能标记为inout
2. inout参数不能有默认值
3. inout参数只能传入可以被多次赋值的
4. inout参数的本质是地址传递(引用传递)

六. 函数重载
规则
函数名相同
参数个数不同 || 参数类型不同 || 参数标签不同
        // 例子
        func sum(v1: Int, v2: Int) -> Int {
            v1 + v2
        }
        
        func sum(v1: Int, v2: Int, v3: Int) -> Int {
            v1 + v2 + v3
        }// 参数个数不同
        
        func sum(v1: Int, v2: Double) -> Double {
            Double(v1) + v2
        } // 参数类型不同

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

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

        func sum(a: Int, b: Int) -> Int {
            a + b
        } // 参数标签不同
函数重载注意点
返回值类型与函数重载无关
函数重载注意点
默认参数值和函数重载一起使用产生二义性时,编译器并不会报错(在C++中会报错)
func sum(v1: Int, v2: Int) -> Int {
      v1 + v2
}
        
func sum(v1:Int, v2: Int, v3: Int = 10) -> Int {
     v1 + v2 + v3
}

// 会调用sum(v1: Int, v2: Int)
sum(v1: 10, v2: 20)
可变参数、省略参数标签、函数重载一起使用产生二义性时,编译器有可能会报错
        func sum(v1: Int, v2: Int) -> Int {
            v1 + v2
        }
        
        func sum(_ v1: Int, _ v2: Int) -> Int {
            v1 + v2
        }
        
        func sum(_ numbers: Int...) -> Int {
            var total = 0
            for number in numbers {
                total += number
            }
            return total
        }
        // error: ambiguous use of 'sum'
        sum(10, 20)
七:内联函数
内联函数在C++这个函数里是有的,那么在swift里面,怎么做的呢?swift内是不需要我们去声明这个函数为内联函数的。
如果开启了编译器优化(Realease 模式默认会开启优化),编译器会自动将某些函数变成内联函数。
我们打开项目。
选择target---> Build Settings ---> 输入optimization 如下图:
image.png

搜索一下,我们会看到有一个Optimization Level 优化级别,默认Debug情况下是NO Optimization(没有优化)。Release(打包的时候)是Optimization for Speed[-D]是有优化的。而且是speed是最快的,按照速度最快的方式去优化。如果我们开启了优化的话,它会自动将我们的某些函数变成内联函数。也就是说,Debug模式下,不会将你的函数,变成内联函数。Release就变成内联函数。Release发布版会自动将某些函数变成内联函数,也就意味这内联函数这种东西是有用的。肯定是可以优化我们程序的系统的。

内联函数作用:
实现以下代码:
func test() -> () {
    print("test")
}        
test()

按照我们正常的理解,当代码调用test()这个函数时,系统会开辟栈空间,给这个函数,在这个函数栈空间里面,去做它相应的事情。比如说分配局部变量,做相应的操作。

等这个函数执行完之后呢?就会将它的栈空间回收,所以这里牵扯一个栈空间的开辟跟回收的一个问题。所以,一旦调用函数就会出这个问题。

如果这段代码能够优化成这样 print("test")性能更好吗?如下图:

//        func test() -> () {
             print("test")
//         }
        
//        test()

因为你这个函数里面的代码,特别的少。就是做一件什么事情,打印。还不如把函数代码抽出来,让它直接打印呢?如下图:
那么,这样不是性能更高吗?内联函数就是这个意思。内联函数会自动将函数调用展开成函数体代码。说白了,是一个怎么样的函数呢?如果你这个test是一个内联函数的话,它会之间将你的函数调用,展开成函数体print("test")。这样就是一种优化,这样可以减少函数的调用开销,就不用开辟栈空间,撤销栈空间。

按照资料来说,Debug是没有优化的,Release是优化的,用汇编看一下到底有没有优化

在test()带一个断点,cmd + R 运行

测试断点

test函数调用转成了汇编,如下图:

test函数汇编图
我们发现test函数被调用了,所以再debug模式下并没有没内联。我们再将这个地方改成release 模式,运行一遍。
会发现一个奇怪的现象,断点没进,但是结果已经打印出来了。所以test()这段代码并没有调用,可以打印出数据,说明print("test")这行代码肯定执行了,那么我们把断点打到print("test")位置,如下图:

汇编如图所示:


发现最上边TestSwift`main:。main函数里面就有print函数
所以,看的出来,我们一旦开启了编译器的优化,它确实会将我们的函数进行内联,直接将它函数体代码,放到这个位置test()。

并不是所有的函数都会被内联,哪些函数不会被内联呢?
函数体比较长

就是如果函数内部,写了很多的时候,它发现代码比较长,它就不会进行内联,它就不会将你的函数体代码放到调用的位置

func test() {
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")
    print("test1111")

}

如果这个函数调用次数比较多,假设如下图test()调用的比较多,那么你要内联的话,那不就相当于把函数里所有代码,main里面放一份,原位置放一份。生成的汇编特别多,最终的机器也就是01、01特别多,所以就会导致你代码的体积就会变大,到时候你的安装包也就会变大,所以这个也是比较智能的。编译器会自动去识别,它认为合适的就会进行内联,不合适的它不会内联,说白了,上面代码,就算你开启了编译器,编译器的优化,它也会变成函数调用,不会给你做内联优化。

包含递归调用的函数也不会内联

如果你包含了递归调用,也不会内联。如下面代码这样写:

func test() {
   test()
}

test()

像这种,编译器也不会内联,内联就是将函数调用展开成函数体代码,然而函数体就这一句 test(),函数外边test(),展开后还是 test(),就是一个死循环,所以编译器也是很聪明的,发现你有递归调用也不会给你内联。

包含动态派发

什么叫动态派发呢?其实就是OC里面的动态绑定,如果包含了动态派发的函数,它也不会进行内联。

比如说,我们有两个类,一个Person类和Student类,Student类继承于Person。 Person中有一个test函数方法,子类Student,重写一下父类的test方法。如下图:


2156697-4a7d1f9c804470c9.png

认真思考一个问题,举个例子


2156697-9f9d6746a851a27c.png

上边图片,的两句代码,明显是一个多态。相当于OC里面的父类指针指向子类对象。那么你想一下test这个函数这个将来肯定要动态派发的。所谓动态派发就是在运行时再决定调用谁的test。

程序运行过程中,根据你的变量指向的对象来调用谁。再举个例子,如果下面有个Teacher类

2156697-520c4d936f2d2b54.png

所以,你思考一下,到时候如下图,可能会变。

2156697-0634c2e50a23bba9.png

就是说到时候,可能会指向Teacher,既然你这个变量,将来指向的对象是随时可能会发生变化的。所以编译器在编译这个代码的时候,没办法确定到底是调用Teacher类、还是Student类中的test,所以这个叫做动态派发。没有办法进行内联。

想一想,内联的前提是什么?我已经确定要调用某个,比如说我确定在编译时期了你要调用某个类的test,那么就将函数体代码放到这个位置如下图:

2156697-421136b6ba015a79.png

这个,肯定不能内联。

关于swift的更多知识
请点击 swift文集

你可能感兴趣的:(swift 5.0 函数及其底层实现)