金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > 内存相关

内存相关

发布时间:2019-11-07 05:07编辑:编程浏览(144)

    /*

    /*

     

     闭包:

     算术运算符: 除了取模, 其它和OC一样, 包括优先级

    /*

     函数是闭包的一种

     + - * / % ++ --

     Swift内存管理:

     类似于OC语言的block

    */

     1.管理引用类型的内存, 不会管理值类型, 值类型不需要管理;

     闭包表达式(匿名函数) -- 能够捕获上下文中的值

    var result = 10 + 10

     2.内存管理原则: 当没任何强引用指向对象, 系统会自动销毁对象(默认情况下所有的引用都是强引用);

     

    result = 10 - 10

     3.如果做到该原则: ARC 自动回收内存

     语法: in关键字的目的是便于区分返回值和执行语句

    result = 10 * 10

     */

     闭包表达式的类型和函数的类型一样, 是参数加上返回值, 也就是in之前的部分

    result = 10 / 10

     

     {

    print(result)

    class Person {

     (参数) -> 返回值类型 in

     

        var name:String

     执行语句

    /*

        init(name:String) {

     }

     注意:Swift是安全严格的编程语言, 会在编译时候检查是否溢出, 但是只会检查字面量而不会检查变量, 所以在Swift中一定要注意隐式溢出

            self.name = name

     

     可以检测

        }

     一般形式:{

     var num1:UInt8 = 255 + 1;

        deinit {

     (parameters) -> returnType in

     无法检测

            print("Person deinit")

     statements

     var num1:UInt8 = 255

        }

     }

     var num2:UInt8 = 250

    }

     */

     var result = num1 + num2

    var p:Person? = Person(name: "xiaohange")

     

     println(result)

    //p = nil

    // 完整写法

     

     

    let say:(String) -> Void = {

     遇到这种问题可以利用溢出运算符解决该问题:

     

        (name: String) -> Void in

     

    /** weak弱引用 **/

        print("hello (name)")

     &+ &- &* &/ &%

    class Person2 {

    }

    */

        var name:String

    say("HaRi")

     

        init(name:String) {

     

    //var num1:UInt8 = 255

            self.name = name

    // 没有返回值写法

    //var num2:UInt8 = 250

        }

    let say2:(String) -> Void = {

    //var result1 = num1 + num2

        deinit {

        (name: String) -> Void in

    //print(result1)

            print("Person2 deinit")

        print("hi (name)")

     

        }

    }

    /*

    }

    say2("HaRi")

    OC: 只对整数取模

    //强引用, 引用计数+1

     

    NSLog("%tu", 10 % 3)

    var strongP = Person2(name: "hjq") //1

    let say3:() ->Void = {

     

    var strongP2 = strongP //2

        print("hello xiaohange")

    Swift:支持小数取模 

     

    }

          注意:2.0支持, 3.0之后就不行了

    //1.弱引用, 引用计数不变;

    say3()

    */

    //2.如果利用weak修饰变量, 当对象释放后会自动将变量设置为nil;

     

    // print(10 % 3.5) //error!

    //3.所以利用weak修饰的变量必定是一个可选类型, 因为只有可选类型才能设置为nil.

    /** 闭包表达式作为回调函数 **/

     

    weak var weakP:Person2? = Person2(name: "hjq")

     

    let value1 = 5.5

    if let p = weakP{

    func showArray(array:[Int]) {

    let value2 = 2.2

        print(p)

        for num in array {

    let result2 = value1.truncatingRemainder(dividingBy: value2)

    }else{

            print("(num)")

    print(result2)

        print(weakP as Any)

        }

     

    }

    }

     

     

    showArray(array: [1,2,3,4])

    /*

    /*

     

     自增 自减

     unowned无主引用, 相当于OC unsafe_unretained

    /*

    */

     unowned和weak的区别:

    // 缺点, 不一定是小到大, 不一定是全部比较, 有可能只比较个位数

    // 在swift3.0之前

     1.利用unowned修饰的变量, 对象释放后不会设置为nil, 不安全;

    // 所以, 如何比较可以交给调用者决定

    // var a = 1

       利用weak修饰的变量, 对象释放后会设置为nil;

    func bubbleSort(inout array:[Int])

    // a++  // 在旧版的Swift中这是可以的,但是在Swift3.0之后就会报错,不能这样写了

     2.利用unowned修饰的变量, 不是可选类型; 利用weak修饰的变量, 是可选类型;

    {

     

     什么时候使用weak?

        let count = array.count;

    // 在Swift3.0之后

     什么时候使用unowned?

        for var i = 1; i < count; i++

    // 只能写成 

     */

        {

    // var b = 1

     

            for var j = 0; j < (count - i); j++

    // b = b + 1 或者 b += 1(建议写法)

    class Person3 {

            {

     

        var name:String

                if array[j] > array[j + 1]

    /*

        init(name:String) {

                {

     赋值运算

            self.name = name

                    let temp = array[j]

     = += -= /= *= %=

        }

                    array[j] = array[j + 1]

    */

        deinit {

                    array[j + 1] = temp

    var num1 = 10

            print("Person3 deinit")

                }

    num1 = 20

        }

            }

    num1 += 10

    }

        }

    num1 -= 10

    unowned var weakP3:Person3 = Person3(name: "hjq")

    }

    num1 *= 10

     

    */

    num1 /= 10

     

     

    num1 %= 5

    /*

    let cmp = {

    print(num1)

     循环引用:

        (a: Int, b:Int) ->Int in

     

     ARC不是万能的, 它可以很好的解决内存问题, 但是在某些场合不能很好的解决内存泄露问题;

        if a > b{

    /*

     例如: 两个或者多个对象之间的循环引用问题

            return 1

     基本用法和OC一样, 唯一要注意的是表达式的值

     */

        }else if a < b

     OC: 表达式的结合方向是从左至右, 整个表达式的值整体的值等于最后一个变量的值, 简而言之就是连续赋值

     

        {

     

    //例1:

            return -1

     Swift: 不允许连续赋值, Swift中的整个表达式是没有值的. 主要是为了避免 if (c == 9) 这种情况误写为 if (c = 9) , c = 9是一个表达式, 表达式是没有值的, 所以在Swift中if (c = 9)不成立

    class Apartment {

        }else

     

        let number:Int      //房间号

        {

     var num2:Int

        var tenant:Person4? //租客

            return 0

     var num3:Int

        init(number:Int) {

        }

     num3 = num2 = 10

            self.number = number

    }

    */

        }

     

     

        deinit {

    func bubbleSort(array : inout [Int], cmp: (Int, Int) -> Int){

     

            print("(self.number) deinit")

        for _ in 0..<array.count {

    /*

        }

            for j in 0..<(array.count - 1) {

     关系运算符, 得出的值是Bool值, 基本用法和OC一样

    }

                if array[j] > array[j + 1] {

     > < >= <= == != ?:

     

                    let temp = array[j]

    */

    class Person4 {

                    array[j] = array[j + 1]

    var result1:Bool = 250 > 100

        let name:String

                    array[j + 1] = temp

    //var result2 = 250 > 100 ? 250 : 100 // 3.0之后不支持了

        weak var apartment: Apartment? //公寓

                }

    print(result1)

        init(name:String) {

            }

     

            self.name = name

        }

    /*

        }

    }

     逻辑运算符,基本用法和OC一样, 唯一要注意的是Swift中的逻辑运算符只能操作Bool类型数据, 而OC可以操作整形(非0即真)

        deinit {

     

     !  && ||

            print("(self.name) deinit")

    var arr:Array<Int> = [23, 34, 56, 15, 8]

    */

        }

    bubbleSort(array: &arr, cmp: cmp)

    var open = false

    }

    showArray(array: arr)

    if !open

     

     

    {

    var p4:Person4? = Person4(name: "han")

    // 闭包作为参数传递

        print("打开")

    var a4:Apartment? = Apartment(number: 888)

    本文由金沙国际官网发布于编程,转载请注明出处:内存相关

    关键词:

上一篇:没有了

下一篇:没有了