iOS 数据类型原理

一、NSCFconstantString

字符串常量类型。即其不能被修改，一旦创建，在应用程序整个运行中不会被回收，OC当中相同的字符串不会重复的消耗内存。

二、NSTaggedPointerString: `标签指针`

一般情况下，指针存储的内容是一个地址，需要根据地址指向的内存空间来获取真正的数据，在64位架构的系统上，这种数据存储方式会有时造成非常浪费空间，很多时候我们存储的数据本身就很少，64位的指针空间就可以容纳下来。
在OC中NSNumber和NSString这类对象就采用了标签指针这种优化方式，当我们是用stringWithFormat这类类方法创建对象时，如果字符串长度较短时，系统就会默认将其创建为NSTaggedPointerString类型的字符串，这样在读取时，通过指针本身就可以解读出内容，节省内存空间的同时也大大加快了数据的访问速度。

三、NSCFString

传统意义的字符串变量，当我们创建的字符串不是常量，且长度较长时，就会自动的以NSCFString类型进行存储，此时字符串对象是受引用计数所影响的，当引用计数为0时，内存会被回收掉。

四、NSPlaceholderString 和 NSPlaceholderMutableString

NSPlaceholderString
当不可变字符串只进行alloc时，实际调用的类似单例的生成对象，且对象地址不会变化。
NSString *string1 = [NSString alloc];
NSString *string2 = [NSString alloc];
NSPlaceholderMutableString
当可变字符串只进行alloc时，实际调用的类似单例的生成对象，且对象地址不会变化。
NSMutableString *mString1 = [NSMutableString alloc];
NSMutableString *mString2 = [NSMutableString alloc];

五、深浅拷贝

浅拷贝通常是对指针进行赋值，即创建一个新的指针变量，让其指向被浅拷贝的对象。在OC中，浅拷贝真正的意义是增加了对象的引用计数，当真正的对象所在内存被回收时，所有浅拷贝出的指针也需要置为空。
深拷贝则是指真正的数据内容拷贝，其会开辟新的内存空间，拷贝出的对象与源对象是完全不同的两个对象，不会影响原对象的引用计数。

NSString

浅拷贝：指针拷贝，引用计数加1。
深拷贝：内容拷贝。
NSMutableString
浅拷贝：内容拷贝，拷贝出的对象是不可变的对象。
深拷贝：内容拷贝。拷贝出的对象是可变对象。

六、Array类簇

NSArray
__NSSingleObjectArrayI:数组只有单个元素时的实际类名。
__NSArrayI: 多个元素时的实际类名。
NSMutableArray: 采用环形缓冲区的内存布局
__NSArrayM: 单个或多个元素的实际类名。

七、Dictionary类簇

NSDictionary: 键值存储的一种数据结构，其内部实际上是使用NSMapTable这种数据类型实现，NSMapTable其实就是一种哈希表。
NSMapTable: 对哈希碰撞的处理采用了关联链表的方式，理想状态下，进行数据查询时间复杂度为o(1),最坏的情况下，所有元素都产生哈希碰撞，时间复杂度为o(n)。

NSDictionary的键通常使用字符串作为数据的键，某一种数据类型如果想要作为键，需要满足两个条件：

遵守NSCoping协议，支持拷贝操作，在NSDictionary内部，键会被拷贝一份，而值会采用引用计数的方式进行强引用。
遵守NSObject协议，并实现其中的两个方法：
-(BOOL)isEqual:(id)object;
@property(readonly) NSUInteget hash;

Dictionary.png

八、哈希表

哈希表：散列表，是存储大量数据的一种方式，哈希表有着非常高的查找效率，理想状态下，其时间复杂度o(1)。哈希表是通过关键码值而直接进行数据访问的数据结构，即通过key值(可能是存放着指向value的地址哈希值)快速的查找value的值。其核心是通过关键码(key)的哈希变换，将其映射到表中的一个位置来进行数据的访问，这个映射的过程通常叫做映射函数或散列函数，用来存放数据的集合叫哈希表或散列表。
哈希碰撞：是指使用不同的关键码key计算出相同的哈希位置，即哈希表实际上是将无限的定义域映射到了有限的值域中，因此从原理上一定会出现哈希碰撞，产生碰撞的元素通常被称为溢出元素。
处理哈希碰撞两种思路：一种是将溢出的元素存储到当前散列表中未存放元素的位置，一种是将溢出的元素存储到散列外面的线性表中。

一、将溢出的元素存储到当前散列中空闲的位置上常用的方法有线性探针法、二次探测法、再散列法。

线性探针法：是指当出现碰撞时，从映射到的位置开始依次向后查找空位置，如果需要也会重置到首位进行查找，使用这种方式进行碰撞处理会使表中大量的连续位置被占用，并且可能会引发更多的碰撞。
二次探测法：与线性探针类似，只是其再查找空闲位置时，是从离初始位置最远的地方开始，修正了线性探针法造成的初始聚集问题。
再散列法：指除了使用一个哈希函数计算散列表中位置外，如果发生碰撞，会使用第二个哈希函数计算偏移步长，即计算出需要移动的长度将数据存入散列表。
线性探针法、二次探测法、再散列法都没有开辟新的存储空间，但是会使位置的计算过程变的复杂，降低效率。

二、将溢出的元素存入散列表以外的地方通常使用拉链法。

拉链法：将同一个散列地址的数据存入一个链表中(或者将溢出的数据存入关联到当前散列位置的链表中)，通常情况下，只要哈希函数的设计合适，散列范围的定义合适，尽量保证散列的均匀，碰撞的概率并不会很大，这是使用拉链法效率处理碰撞效率很高。

九、Swift指针

        // 一、指针
        var a = 10
         // 1.UnsafePointer
        var a_pointer = withUnsafePointer(to: &a) { (pointer) -> UnsafePointer<Int> in
            return pointer
        }
        print(a_pointer.pointee)
        a_pointer.pointee = 11 // UnsafePointer：不可变指针，不能修改指针的值
        
         //2. UnsafeMutablePointer 可变类型指针，可以修改指针的值
        var a_p = withUnsafeMutablePointer(to: &a) { (pointer) -> UnsafeMutablePointer<Int> in
            return pointer
        }

        a_p.pointee = 11
        print(a_p.pointee)
        print(a)
        
         // 二、修改指针的值
        update1(b: &a)
        print(a)

        update2(b: &a)
        print(a)
        
        
         // 申请连续的内存
        var p = UnsafeMutablePointer<Int>.allocate(capacity: 2) // 申请2个int数据类型的内存大小
        // 初始化 allocate(capacity: 2)当申请2个内存大小时，p.initialize(to: 10) 默认填充的是第一个内存位置
        p.initialize(to: 10)
        p[1] = 11
        // 使用
        print(p.pointee)
        print(p.successor().pointee) //  successor() 访问下一个内存位置的指针
        p.pointee = 11
        print(p.pointee)
        // 析构, 1: 析构的内存大小
        p.deinitialize(count: 1)
       // 释放内存
        p.deallocate() 
        
        //三、 数组指针
        var arr = [1, 2, 3, 4, 5]
        let arr_p = UnsafeMutableBufferPointer<Int>(start: &arr, count: arr.count)
        if var base = arr_p.baseAddress {
            var i = 0
            while i < arr_p.count {
                print(base.pointee)
                base = base.successor()
                i += 1
            }
       }


    func updatePointer1(b: UnsafeMutablePointer<Int>) {
        b.pointee += 1
    }

    func updatePointer2( b: inout Int) {
        b += 1
    }

-----------------------------指针与内存----------------------------------
        // 四、指针与内存管理
        var person: Person? = Person(name: "Lili")
//        var person_p = withUnsafePointer(to: &person!) { (pointer) -> UnsafePointer<Person> in
//            return pointer
//        }
//        print(person_p.pointee.name)
//        person = nil
//        print(person_p.pointee.name) //person为nil，会出现异常
        
        //
        var person_un = Unmanaged.passRetained(person!) //  创建非托管的对象，这时person是需要我们来控制生命周期，而不是ARC来管理， passRetained 使用person引用计数加1
        person = nil
        let person_o = person_un.toOpaque()
        // 将一个指针转换为指定的类型
        let personCast = unsafeBitCast(person_o, to: Person.self)
        print(personCast.name)
        person_un.release()// 释放


    class Person {
    var name: String?
    
    init(name: String) {
        self.name = name
    }
}