Swift-05：內存管理

swift中的內存管理，涉及引用計數、弱引用、強引用、循環引用、Runtime是什么樣子的呢？

內存管理 - 強引用

在swift中也是使用ARC來追蹤和管理內存的，下面我們通過一個案例來進行分析

class CJLTeacher {
    var age: Int = 18
    var name: String = "CJL"
}
var t = CJLTeacher()
var t1 = t
var t2 = t

  • 查看t的內存情況，為什么其中的refCounts是0x0000000600000003？

    image

在分析類時（參考這篇文章Swift-進階 02：類、對象、屬性）有這么一個類HeapObject，下面繼續通過這個類來分析t的引用計數

  • 分析源碼 HeapObject -> InlineRefCounts 
struct HeapObject {
  HeapMetadata const *metadata;

  SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS;
  ...
}
??
#define SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS       \
  InlineRefCounts refCounts
  • 進入InlineRefCounts定義，是RefCounts類型的別名，而RefCounts是模板類，真正決定的是傳入的類型InlineRefCountBits 
typedef RefCounts<InlineRefCountBits> InlineRefCounts;
??
template <typename RefCountBits>
class RefCounts {
  std::atomic<RefCountBits> refCounts;
  ...
}
  • 分析InlineRefCountBits，是RefCountBitsT類的別名
typedef RefCountBitsT<RefCountIsInline> InlineRefCountBits;
  • 分析RefCountBitsT，有bits屬性
template <RefCountInlinedness refcountIsInline>
class RefCountBitsT {
    ...
      typedef typename RefCountBitsInt<refcountIsInline, sizeof(void*)>::Type
    BitsType;
    ...
    BitsType bits;
    ...
}
??
template <>
struct RefCountBitsInt<RefCountNotInline, 4> {
  //類型
  typedef uint64_t Type;
  typedef int64_t SignedType;
};

其中bits其實質是將RefCountBitsInt中的type屬性取了一個別名，所以bits的真正類型是uint64_t即64位整型數組

然后來繼續分析swift中對象創建的底層方法swift_allocObject

  • 分析初始化源碼swift_allocObject 
static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                       size_t requiredSize,
                                       size_t requiredAlignmentMask) {
    ...
    new (object) HeapObject(metadata);
    ...
}
??
<!--構造函數-->
 constexpr HeapObject(HeapMetadata const *newMetadata) 
    : metadata(newMetadata)
    , refCounts(InlineRefCounts::Initialized)
  { }
  • 進入Initialized定義，是一個枚舉，其對應的refCounts方法中，
  enum Initialized_t { Initialized };

  //對應的RefCounts方法
// Refcount of a new object is 1.
constexpr RefCounts(Initialized_t)
: refCounts(RefCountBits(0, 1)) {}

從這里看出真正干事的是RefCountBits

  • 進入RefCountBits定義，也是一個模板定義
template <typename RefCountBits>
class RefCounts {
  std::atomic<RefCountBits> refCounts;
  ...
}

所以真正的初始化地方是下面這個，實際上是做了一個位域操作，根據的是Offsets

LLVM_ATTRIBUTE_ALWAYS_INLINE
constexpr
RefCountBitsT(uint32_t strongExtraCount, uint32_t unownedCount)
: bits((BitsType(strongExtraCount) << Offsets::StrongExtraRefCountShift) |
       (BitsType(1)                << Offsets::PureSwiftDeallocShift) |
       (BitsType(unownedCount)     << Offsets::UnownedRefCountShift))
{ }

分析RefCountsBit的結構，如下所示，

image

  • isImmortal（0）

  • UnownedRefCount（1-31）： unowned的引用計數

  • isDeinitingMask（32）：是否進行釋放操作

  • StrongExtraRefCount（33-62）： 強引用計數

  • UseSlowRC（63）

重點關注UnownedRefCount和StrongExtraRefCount

  • 將t的refCounts用二進制展示，其中強引用計數為3

    image

分析SIL代碼

  • 當只有t實例變量時

    image

  • 當有t + t1時，查看是否有 strong_retain操作

//SIL中的main
alloc_global @main.t1 : main.CJLTeacher       // id: %8
%9 = global_addr @main.t1 : main.CJLTeacher : $*CJLTeacher // user: %11
%10 = begin_access [read] [dynamic] %3 : $*CJLTeacher // users: %12, %11
copy_addr %10 to [initialization] %9 : $*CJLTeacher // id: %11

//其中copy_addr等價于
- %new = load s*LGTeacher
- strong_retain %new
- store %new to %9
image

SIL官方文檔中關于copy_addr的解釋如下

image
  • 其中的strong_retain對應的就是 swift_retain，其內部是一個宏定義，內部是_swift_retain_，其實現是對object的引用計數作+1操作
//內部是一個宏定義
HeapObject *swift::swift_retain(HeapObject *object) {
  CALL_IMPL(swift_retain, (object));
}
??
//本質調用的就是 _swift_retain_
static HeapObject *_swift_retain_(HeapObject *object) {
  SWIFT_RT_TRACK_INVOCATION(object, swift_retain);
  if (isValidPointerForNativeRetain(object))
    object->refCounts.increment(1);
  return object;
}
??
void increment(uint32_t inc = 1) {
    auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);

    // constant propagation will remove this in swift_retain, it should only
    // be present in swift_retain_n
    if (inc != 1 && oldbits.isImmortal(true)) {
      return;
    }
    //64位bits
    RefCountBits newbits;
    do {
      newbits = oldbits;
      bool fast = newbits.incrementStrongExtraRefCount(inc);
      if (SWIFT_UNLIKELY(!fast)) {
        if (oldbits.isImmortal(false))
          return;
        return incrementSlow(oldbits, inc);
      }
    } while (!refCounts.compare_exchange_weak(oldbits, newbits,
                                              std::memory_order_relaxed));
  }
  • 回退到HeapObject，從InlineRefCounts進入，其中是c++中的模板定義，是為了更好的抽象，在其中查找bits（即decrementStrongExtraRefCount方法）
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE
bool incrementStrongExtraRefCount(uint32_t inc) {
// This deliberately overflows into the UseSlowRC field.
// 對inc做強制類型轉換為 BitsType
// 其中 BitsType(inc) << Offsets::StrongExtraRefCountShift 等價于 1<<33位，16進制為 0x200000000
//這里的 bits += 0x200000000，將對應的33-63轉換為10進制，為
bits += BitsType(inc) << Offsets::StrongExtraRefCountShift;
return (SignedBitsType(bits) >= 0);
}

例如以t的refCounts為例（其中62-33位是strongCount，每次增加強引用計數增加都是在33-62位上增加的，固定的增量為1左移33位，即0x200000000）

  • 只有t時的refCounts是 0x0000000200000003

  • t + t1時的refCounts是 0x0000000400000003 = 0x0000000200000003 + 0x200000000

  • t + t1 + t2 時的refCounts是 0x0000000600000003 = 0x0000000400000003 + 0x200000000

  • 針對上面的例子，可以通過CFGetRetainCOunt獲取引用計數,發現依次是 2、3、4，默認多了一個1

    image

  • 如果將t、t1、t2放入函數中，還會再次retain一次

    image

為什么是0x200000000？
因為1左移33位，其中4位為一組，計算成16進制，剩余的33-32位0x10，轉換為10進制為2。其實際增加引用技術就是1

swift與OC強引用計數對比

  • OC中創建實例對象時為0

  • swift中創建實例對象時默認為1

內存管理 - 弱引用

以下面為例：

class CJLTeacher {
    var age: Int = 18
    var name: String = "CJL"
    var stu: CJLStudent?
}

class CJLStudent {
    var age = 20
    var teacher: CJLTeacher?
}

func test(){
    var t = CJLTeacher()
    weak var t1 = t
}

  • 查看t的引用計數變化

    image

  • 弱引用聲明的變量是一個可選值，因為在程序運行過程中是允許將當前變量設置為nil的

  • 在t1處加斷點，查看匯編

    image

  • 查看 swift_weakInit函數，這個函數是由WeakReference來調用的，相當于weak字段在編譯器聲明過程中就自定義了一個WeakReference的對象，其目的在于管理弱引用

WeakReference *swift::swift_weakInit(WeakReference *ref, HeapObject *value) {
  ref->nativeInit(value);
  return ref;
}
  • 進入nativeInit 
void nativeInit(HeapObject *object) {
auto side = object ? object->refCounts.formWeakReference() : nullptr;
nativeValue.store(WeakReferenceBits(side), std::memory_order_relaxed);
}
  • 進入formWeakReference，創建sideTable，
template <>
HeapObjectSideTableEntry* RefCounts<InlineRefCountBits>::formWeakReference()
{
  //創建 sideTable
  auto side = allocateSideTable(true);
  if (side)
  // 如果創建成功，則增加弱引用
    return side->incrementWeak();
  else
    return nullptr;
}
  • 進入allocateSideTable 
template <>
HeapObjectSideTableEntry* RefCounts<InlineRefCountBits>::allocateSideTable(bool failIfDeiniting)
{
  // 1、先拿到原本的引用計數
  auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);

  // Preflight failures before allocating a new side table.
  if (oldbits.hasSideTable()) {
    // Already have a side table. Return it.
    return oldbits.getSideTable();
  } 
  else if (failIfDeiniting && oldbits.getIsDeiniting()) {
    // Already past the start of deinit. Do nothing.
    return nullptr;
  }

  // Preflight passed. Allocate a side table.

  // FIXME: custom side table allocator
  //2、創建sideTable
  HeapObjectSideTableEntry *side = new HeapObjectSideTableEntry(getHeapObject());
  // 3、將創建的地址給到InlineRefCountBits
  auto newbits = InlineRefCountBits(side);

  do {
    if (oldbits.hasSideTable()) {
      // Already have a side table. Return it and delete ours.
      // Read before delete to streamline barriers.
      auto result = oldbits.getSideTable();
      delete side;
      return result;
    }
    else if (failIfDeiniting && oldbits.getIsDeiniting()) {
      // Already past the start of deinit. Do nothing.
      return nullptr;
    }

    side->initRefCounts(oldbits);

  } while (! refCounts.compare_exchange_weak(oldbits, newbits,
                                             std::memory_order_release,
                                             std::memory_order_relaxed));
  return side;
}

  • 1、先拿到原本的引用計數

  • 2、創建sideTable

  • 3、將創建的sideTable地址給InlineRefCountBits，并查看其初始化方法，根據sideTable地址作了偏移操作并存儲到內存，相當于將sideTable直接存儲到了64位的變量中

    image

    所以上面的0xc000000020809a6c是HeapObjectSideTableEntry實例對象的內存地址，即散列表的地址（除去63、62位）

    • 查看HeapObjectSideTableEntry定義，其中有object對象、refCounts

      image

    • 進入SideTableRefCounts，同InlineRefCounts類似，實際做事的是SideTableRefCountBits，繼承自RefCountBitsT（存的是uint64_t類型的64位的信息），還有一個uint32_t的weakBits，即32位的位域信息

      • 64位 用于記錄 原有引用計數
      • 32位 用于記錄 弱引用計數
    image

以0xc000000020809a6c為例，將62、63位清零，變成0x20809A6C，然后左移3位（即InlineRefCountBits初始化方法），變成0x10404D360即HeapObjectSideTableEntry對象地址，即散列表地址，然后通過x/8g讀取

image

問題：如果此時再加一個強引用t2
查看其refCounts，t2是執行了strong_retain的

image

  • 源碼查看 _swift_retain_ -> increment -> incrementSlow -> incrementStrong

    image

總結

對于HeapObject來說，其refCounts有兩種：

  • 無弱引用：strongCount + unownedCount
  • 有弱引用：object + xxx + （strongCount + unownedCount） + weakCount
HeapObject {
    InlineRefCountBit {strong count + unowned count }

    HeapObjectSideTableEntry{
        HeapObject *object
        xxx
        strong Count + unowned Count（uint64_t）//64位
        weak count（uint32_t)//32位
    }
}

內存管理 - 循環引用

主要是研究閉包捕獲外部變量，以下面代碼為例

var age = 10
let clourse = {
    age += 1
}
clourse()
print(age)

<!--打印結果-->
11

從輸出結果中可以看出：閉包內部對變量的修改將會改變外部原始變量的值,主要原因是閉包會捕獲外部變量，這個與OC中的block是一致的

  • 定義一個類，在test函數作用域消失后，會執行init
class CJLTeacher {
    var age = 18
    //反初始化器（當前實例對象即將被回收）
    deinit {
        print("CJLTeacher deinit")
    }
}
func test(){
    var t = CJLTeacher()
}
test()

<!--打印結果-->
CJLTeacher deinit
  • 修改例子，通過閉包修改其屬性值
class CJLTeacher {
    var age = 18
    //反初始化器（當前實例對象即將被回收）
    deinit {
        print("CJLTeacher deinit")
    }
}
var t = CJLTeacher()
let clourse = {
    t.age += 1
}
clourse()

<!--打印結果-->
11
  • 【修改1】將上面例子修改為如下，其中閉包是否對t有強引用？
class CJLTeacher {
    var age = 18
    deinit {
        print("CJLTeacher deinit")
    }
}

func test(){
    var t = CJLTeacher()
    let clourse = {
        t.age += 1
    }
    clourse()
}
test()

<!--運行結果-->
CJLTeacher deinit

運行結果發現，閉包對 t 并沒有強引用

  • 【修改2】繼續修改例子為如下，是否有強引用？
class CJLTeacher {
    var age = 18

    var completionBlock: (() ->())?

    deinit {
        print("CJLTeacher deinit")
    }
}

func test(){
    var t = CJLTeacher()
    t.completionBlock = {
        t.age += 1
    }
}
test()

從運行結果發現，沒有執行deinit方法，即沒有打印CJLTeacher deinit，所以這里有循環引用

image

循環引用解決方法

有兩種方式可以解決swift中的循環引用

  • 【方式一】使用weak修飾閉包傳入的參數，其中參數的類型是optional 
func test(){
    var t = CJLTeacher()
    t.completionBlock = { [weak t] in
        t?.age += 1
    } 
}
  • 【方式二】使用unowned修飾閉包參數，與weak的區別在于unowned不允許被設置為nil，即總是假定有值的
func test(){
    var t = CJLTeacher()
    t.completionBlock = { [unowned t] in
        t.age += 1
    } 
}

捕獲列表

  • [weak t] / [unowned t] 在swift中被稱為捕獲列表

  • 定義在參數列表之前

  • 【書寫方式】捕獲列表被寫成用逗號括起來的表達式列表，并用方括號括起來

  • 如果使用捕獲列表，則即使省略參數名稱、參數類型和返回類型，也必須使用in關鍵字

  • [weak t] 就是取t的弱引用對象 類似weakself

請問下面代碼的clourse()調用后，輸出的結果是什么？

func test(){
    var age = 0
    var height = 0.0
    //將變量age用來初始化捕獲列表中的常量age，即將0給了閉包中的age（值拷貝）
    let clourse = {[age] in
        print(age)
        print(height)
    }
    age = 10
    height = 1.85
    clourse()
}

<!--打印結果-->
0
1.85

所以從結果中可以得出：對于捕獲列表中的每個常量，閉包會利用周圍范圍內具有相同名稱的常量/變量，來初始化捕獲列表中定義的常量。有以下幾點說明：

  • 捕獲列表中的常量是值拷貝，而不是引用

  • 捕獲列表中的常量的相當于復制了變量age的值

  • 捕獲列表中的常量是只讀的，即不可修改

swift中Runtime探索

請問下面代碼，會打印方法和屬性嗎？

class CJLTeacher {
    var age: Int = 18
    func teach(){
        print("teach")
    }
}

let t = CJLTeacher()

func test(){
    var methodCount: UInt32 = 0
    let methodList = class_copyMethodList(CJLTeacher.self, &methodCount)
    for i in 0..<numericCast(methodCount) {
        if let method = methodList?[i]{
            let methodName = method_getName(method)
            print("方法列表：\(methodName)")
        }else{
            print("not found method")
        }
    }

    var count: UInt32 = 0
    let proList = class_copyPropertyList(CJLTeacher.self, &count)
    for i in 0..<numericCast(count) {
        if let property = proList?[i]{
            let propertyName = property_getName(property)
            print("屬性成員屬性:\(property)")
        }else{
            print("沒有找到你要的屬性")
        }
    }
    print("test run")
}
test()

運行結果如下，發現并沒有打印方法和屬性

image

  • 【嘗試1】如果給屬性 和 方法 都加上 @objc，可以打印嗎？

    image

    從運行結果看，是可以打印，但是由于類并沒有暴露給OC，所以OC是無法使用的，這樣做是沒有意義的

  • 【嘗試2】如果swift的類繼承NSObject，沒有@objc修飾屬性和方法，是否可以打印全部屬性+方法？

    image

    從結果發現獲取的只有init方法，主要是因為在 swift.h文件中暴露出來的只有init方法

  • 如果想讓OC能使用，必須類繼承NSObject + @objc修飾屬性、方法

    image

  • 如果去掉@objc修飾屬性，將方法改成dynamic修飾，是否可以打印方法？

    image

    從結果可以看出，依舊不能被OC獲取到，需要修改為@objc dynamic修飾

    image

結論

  • 對于純swift類來說，沒有 動態特性dynamic（因為swift是靜態語言），方法和屬性不加任何修飾符的情況下，已經不具備runtime特性，此時的方法調度，依舊是函數表調度即V_Table調度

  • 對于純swift類，方法和屬性添加@objc標識的情況下，可以通過runtime API獲取到，但是在OC中是無法進行調度的，原因是因為swift.h文件中沒有swift類的聲明

  • 對于繼承自NSObject類來說，如果想要動態的獲取當前屬性+方法，必須在其聲明前添加 @objc關鍵字，如果想要使用方法交換，還必須在屬性+方法前添加dynamic關鍵字，否則當前屬性+方法只是暴露給OC使用，而不具備任何動態特性

objc源碼驗證

（由于xcode12.2暫時無法運行objc源碼，下列驗證圖片僅供參考）

  • 進入class_copyMethodList源碼,斷住，查看此時的cls，其中data()存儲類的信息

    image

  • 進入data，打印bits、superclass

    image

    從這里可以得出swift中有默認基類，即_SwiftObject

  • 打印methods

    image

  • swift源碼中搜索_SwiftObject，繼承自NSObject，在內存結構上與OC基本類似的

#if __has_attribute(objc_root_class)
__attribute__((__objc_root_class__))
#endif
SWIFT_RUNTIME_EXPORT @interface SwiftObject<NSObject> {
 @private
  Class isa;
  //refCounts
  SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS;
}

  • 在之前的文章中Swift-進階 02：類、對象、屬性，其中TargetAnyClassMetadata繼承自TargetHeapMetaData，其中只有一個屬性kind，TargetAnyClassMetadata有四個屬性：isa、superclass、cacheData、data即bits

    image

    所以swift為了保留和OC交互，其在底層存儲的數據結構上和OC是一致的

  • objc源碼中搜索swift_class_t，繼承自objc_class，保留了OC模板類的4個屬性，其次才是自己的屬性

struct swift_class_t : objc_class {
    uint32_t flags;
    uint32_t instanceAddressOffset;
    uint32_t instanceSize;
    uint16_t instanceAlignMask;
    uint16_t reserved;

    uint32_t classSize;
    uint32_t classAddressOffset;
    void *description;
    // ...

    void *baseAddress() {
        return (void *)((uint8_t *)this - classAddressOffset);
    }
};

問題：為什么繼承NSObject？：必須通過NSObject聲明，來幫助編譯器判斷，當前類是一個和OC交互的類

元類型、AnyClass、Self

AnyObject

  • AnyObject：代表任意類的instance、類的類型、僅類遵守的協議
class CJLTeacher: NSObject {
    var age: Int = 18
}

var t = CJLTeacher()

//此時代表的就是當前CJLTeacher的實例對象
var t1: AnyObject = t

//此時代表的是CJLTeacher這個類的類型
var t2: AnyObject = CJLTeacher.self

//繼承自AnyObject，表示JSONMap協議只有類才可以遵守
protocol JSONMap: AnyObject { }

例如如果是結構體遵守協議，會報錯

image

需要將struct修改成class

//繼承自AnyObject，表示JSONMap協議只有類才可以遵守
protocol JSONMap: AnyObject {

}
class CJLJSONMap: JSONMap {

}

Any

  • Any：代表任意類型，包括 function類型 或者Optional類型,可以理解為AnyObject是Any的子集
//如果使用AnyObject會報錯，而Any不會
var array: [Any] = [1, "cjl", "", true]

AnyClass

  • AnyClass：代表任意實例的類型 ，類型是AnyObject.Type
    • 查看定義,是public typealias AnyClass = AnyObject.Type

T.self & T.Type

  • T.self：

    • 如果T是實例對象，返回的就是它本身

    • 如果T是類，那么返回的是MetaData

  • T.Type：一種類型，

  • T.self 是 T.Type類型

//此時的self類型是  CJLTeacher.Type
var t = CJLTeacher.self

打印結果如下

image
  • 查看t1、t2存儲的是什么？
var t = CJLTeacher()
//實例對象地址：實例對象.self 返回實例對象本身
var t1 = t.self
//存儲metadata元類型
var t2 = CJLTeacher.self
image

type(of:)

  • type(of:)：用來獲取一個值的動態類型
<!--demo1-->
var age = 10 as NSNumber
print(type(of: age))

<!--打印結果-->
__NSCFNumber

<!--demo2-->
//value - static type 靜態類型：編譯時期確定好的
//type(of:) - dynamic type：Int
var age = 10
//value的靜態類型就是Any
func test(_ value: Any){

    print(type(of: value))
}

test(age)

<!--打印結果-->
Int

實踐

demo1

請問下面這段代碼的打印結果是什么？

class CJLTeacher{
    var age = 18
    var double = 1.85
    func teach(){
        print("LGTeacher teach")
    }
}
class CJLPartTimeTeacher: CJLTeacher {
    override func teach() {
        print("CJLPartTimeTeacher teach")
    }
}

func test(_ value: CJLTeacher){
    let valueType = type(of: value)
    value.teach()
    print(value)
}
var t = CJLPartTimeTeacher()
test(t)

<!--打印結果-->
CJLPartTimeTeacher teach
CJLTest.CJLPartTimeTeacher

demo2

請問下面代碼的打印結果是什么？

protocol TestProtocol {

}
class CJLTeacher: TestProtocol{
    var age = 18
    var double = 1.85
    func teach(){
        print("LGTeacher teach")
    }
}

func test(_ value: TestProtocol){
    let valueType = type(of: value)
    print(valueType)
}
var t = CJLTeacher()
let t1: TestProtocol = CJLTeacher()
test(t)
test(t1)

<!--打印結果-->
CJLTeacher
CJLTeacher
  • 如果將test中參數的類型修改為泛型，此時的打印是什么？
func test<T>(_ value: T){
    let valueType = type(of: value)
    print(valueType)
}

<!--打印結果-->
CJLTeacher
TestProtocol

從結果中發現，打印并不一致，原因是因為當有協議、泛型時，當前的編譯器并不能推斷出準確的類型，需要將value轉換為Any，修改后的代碼如下：

func test<T>(_ value: T){
    let valueType = type(of: value as Any)
    print(valueType)
}

<!--打印結果-->
CJLTeacher
CJLTeacher

demo3

在上面的案例中，如果class_getClassMethod中傳t.self，可以獲取方法列表嗎？

func test(){
    var methodCount: UInt32 = 0
    let methodList = class_copyMethodList(t.self, &methodCount)
    for i in 0..<numericCast(methodCount) {
        if let method = methodList?[i]{
            let methodName = method_getName(method)
            print("方法列表：\(methodName)")
        }else{
            print("not found method")
        }
    }

    var count: UInt32 = 0
    let proList = class_copyPropertyList(CJLTeacher.self, &count)
    for i in 0..<numericCast(count) {
        if let property = proList?[i]{
            let propertyName = property_getName(property)
            print("屬性成員屬性:\(property)")
        }else{
            print("沒有找到你要的屬性")
        }
    }
    print("test run")
}
test()

從結果運行看，并不能，因為t.self是實例對象本身，即CJLTeacher，并不是CJLTeacher.Type類型

總結

  • 當無弱引用時，HeapObject中的refCounts等于 strongCount + unownedCount

  • 當有弱引用時，HeapObject中的refCounts等于 object + xxx + （strongCount + unownedCount) + weakCount

  • 循環應用可以通過weak / unowned修飾參數來解決

  • swift中閉包的捕獲列表是值拷貝，即深拷貝，是一個只讀的常量

  • swift由于是靜態語言，所以屬性、方法在不加任何修飾符的情況下時是不具備動態性即Runtime特性的，此時的方法調度是V-Table函數表調度

  • 如果想要OC使用swift類中的方法、屬性，需要class繼承NSObject，并使用@objc修飾

  • 如果想要使用方法交換，除了繼承NSObject+@objc修飾，還必須使用dynamic修飾

  • Any：任意類型，包括function類型、optional類型

  • AnyObject：任意類的instance、類的類型、僅類遵守的協議，可以看作是Any的子類

  • AnyClass：任意實例類型，類型是AnyObject.Type

  • T.self：如果T是實例對象，則表示它本身，如果是類，則表示metadata.T.self的類型是T.Type

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 230,247評論 6贊 543
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 99,520評論 3贊 429
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 178,362評論 0贊 383
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,805評論 1贊 317
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 72,541評論 6贊 412
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,896評論 1贊 328
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,887評論 3贊 447
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 43,062評論 0贊 290
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,608評論 1贊 336
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 41,356評論 3贊 358
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,555評論 1贊 374
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 39,077評論 5贊 364
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,769評論 3贊 349
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 35,175評論 0贊 28
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 36,489評論 1贊 295
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 52,289評論 3贊 400
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,516評論 2贊 379

推薦閱讀更多精彩內容