Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Ulteriori informazioni su Objective-C isa struttura della memoria del puntatore

Nell'Obiettivo C,isa I puntatori sono un importante ponte tra oggetti e classi. Non solo aiuta il sistema runtime a identificare il tipo di oggetto, ma partecipa anche ad alcune ottimizzazioni della memoria e delle prestazioni.Questo articolo spiegherà in modo approfonditoisa La struttura della memoria dei puntatori, inclusa la sua evoluzione nelle implementazioni antiche e moderne.

cosa è isa puntatore?

Ogni oggetto Objective-C ha a isa Puntatore che punta all'oggetto classe di un oggetto.Anche l'oggetto classe stesso è un oggetto, e il suo fileisa Il puntatore punta a un oggetto meta-classe.Gli oggetti Metaclass memorizzano i metodi delle classi e i loro fileisa Il puntatore punta infine alla metaclasse radice (solitamenteNSObject metaclasse).

Presto isa struttura del puntatore

Nelle prime implementazioni Objective-C,isa Il puntatore punta semplicemente a una struttura di oggetti di classe. Ecco un tipico esempio di implementazione iniziale:

struct objc_object {
    Class isa; // 指向类对象的指针
};

typedef struct objc_class *Class; // Class 的本质是 objc_class 类型的结构体指针
struct objc_class {
    Class isa; // 指向元类对象的指针
    Class super_class; // 指向父类对象的指针
    // 其他类相关的元数据
};
1
2
3
4
5
6
7
8
9
10

Sotto questa struttura:

• Oggetto isa Il puntatore punta all'oggetto della classe.
• simile ad un oggetto isa Il puntatore punta all'oggetto metaclasse.
• oggetto metaclasse isa Il puntatore punta all'oggetto metaclasse root.

moderno isa struttura del puntatore

Sui sistemi a 64 bit e sui moderni runtime Objective-C,isa I puntatori sono stati ridisegnati come un'unione più complessa (union isa_t ), che non contiene solo puntatori a oggetti di classe, ma anche altri flag e informazioni per ottimizzare l'utilizzo e le prestazioni della memoria.Quello che segue èisa_t Un esempio semplificato di struttura:

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls; // 指向类对象的指针
    uintptr_t bits; // 包含位域信息的位模式

    struct {
        uintptr_t nonpointer        : 1;  // 是否启用优化的 non-pointer isa
        uintptr_t has_assoc         : 1;  // 是否有关联对象
        uintptr_t has_cxx_dtor      : 1;  // 是否有 C++ 析构函数
        uintptr_t shiftcls          : 33; // 类指针（经过位移和压缩）
        uintptr_t magic             : 6;  // 调试用的魔数
        uintptr_t weakly_referenced : 1;  // 是否被弱引用
        uintptr_t deallocating      : 1;  // 是否正在释放
        uintptr_t has_sidetable_rc  : 1;  // 是否有辅助引用计数表
        uintptr_t extra_rc          : 19; // 额外的引用计数
    };
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Spiegazione del campo struttura

• non puntatore:istruire isa Se si tratta di un tipo non puntatore (ottimizza il layout della memoria, memorizza informazioni aggiuntive).
• ha_associato: se all'oggetto sono associati riferimenti (riferimenti associativi).
• ha_cxx_dtor: se l'oggetto ha un distruttore C++ e il distruttore deve essere chiamato.
• spostamento: puntatore di classe, che memorizza le informazioni sulla classe dell'oggetto (dopo lo spostamento e la compressione).
• Magia: numero magico utilizzato per il debug e la verifica del runtime.
• debolmente referenziato: se l'oggetto è indicato da un riferimento debole.
• deallocazione: se l'oggetto viene rilasciato.
• ha_un_tavolo_laterale_rc: se il conteggio dei riferimenti dell'oggetto è memorizzato nella tabella ausiliaria (tabella laterale).
• extra_rc: conteggio dei riferimenti aggiuntivo per ottimizzare l'utilizzo della memoria.

Archiviazione e gestione dei conteggi di riferimento

Nelle prime implementazioni Objective-C, il conteggio dei riferimenti veniva solitamente archiviato direttamente nell'oggetto come parte della struttura dell'oggetto. Per esempio:

struct objc_object {
    Class isa; // 指向类对象的指针
    uintptr_t retainCount; // 引用计数
};
1
2
3
4

Nei moderni runtime Objective-C, il conteggio dei riferimenti avviene tramite isa Viene gestita la struttura ottimizzata dei puntatori e la struttura dati ausiliari della Side Table.

• Conteggio dei riferimenti in linea: Le informazioni sul conteggio dei riferimenti parziali vengono memorizzate in isa In strutture ottimizzate di puntatori, ad es.extra_rc campo.
• Tavolino: quando il conteggio dei riferimenti supera isa Quando viene raggiunto l'intervallo che un puntatore può rappresentare, il conteggio dei riferimenti viene archiviato in una struttura dati ausiliaria denominata Side Table.

Moderno isa Vantaggi dei puntatori

• Ottimizzazione della memoria: memorizzando più informazioni (come conteggi di riferimenti, flag) in isa Nei puntatori l'accesso ad altre aree di memoria viene ridotto e le prestazioni migliorate.
• Miglioramenti delle prestazioni: Le operazioni di lettura della memoria sono ridotte poiché è possibile ottenere più informazioni in una lettura della memoria.
• Metadati più ricchi: può contenere più informazioni di runtime, contribuendo a migliorare la flessibilità e l'efficienza del runtime.

Esempio di utilizzo

Sebbene gli sviluppatori spesso non interagiscano direttamente con isa I puntatori interagiscono, ma comprenderne la struttura è utile per il debug e l'ottimizzazione delle prestazioni. Ecco un esempio di utilizzo che visualizza il tipo di un oggetto accedendo alle informazioni sulla sua classe:

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface MyClass : NSObject
@end

@implementation MyClass
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MyClass *obj = [[MyClass alloc] init];
        Class cls = object_getClass(obj);
        NSLog(@"Class name: %s", class_getName(cls));
        
        // 访问 isa 指针信息（需要通过运行时函数）
        NSLog(@"isa pointer: %p", *(uintptr_t *)obj);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Riassumere

isa I puntatori svolgono un ruolo importante nel runtime Objective-C, dai primi semplici puntamenti agli oggetti di classe fino al complesso modernoisa_t struttura, che aiuta a ottimizzare l'utilizzo e le prestazioni della memoria.capireisa L'evoluzione dei puntatori e delle strutture di memoria può aiutarci a comprendere meglio il meccanismo di runtime di Objective-C e a scrivere codice efficiente.

Spero che questo articolo possa aiutarti ad acquisire una comprensione più profonda di Objective-C isa Struttura della memoria del puntatore. Se hai domande o suggerimenti, lascia un messaggio per la discussione.