Partage de technologie

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

En savoir plus sur Objective-C isa structure de la mémoire du pointeur

En Objective-C,isa Les pointeurs constituent un pont important entre les objets et les classes. Cela aide non seulement le système d'exécution à identifier le type d'objet, mais participe également à certaines optimisations de mémoire et de performances.Cet article expliquera en profondeurisa La structure de la mémoire des pointeurs, y compris son évolution dans les implémentations anciennes et modernes.

qu'est-ce que isa aiguille?

Chaque objet Objective-C a un isa Un pointeur qui pointe vers l'objet de classe d'un objet.L'objet de classe lui-même est également un objet, et sonisa Le pointeur pointe vers un objet méta-classe.Les objets métaclasses stockent les méthodes de classe et leursisa Le pointeur pointe finalement vers la métaclasse racine (généralementNSObject métaclasse).

Tôt isa structure du pointeur

Dans les premières implémentations Objective-C,isa Le pointeur pointe simplement vers une structure d’objets de classe. Voici un exemple typique de mise en œuvre précoce :

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

Sous cette structure :

• Objet isa Le pointeur pointe vers l’objet de classe.
• semblable à un objet isa Le pointeur pointe vers l’objet métaclasse.
• objet métaclasse isa Le pointeur pointe vers l’objet métaclasse racine.

moderne isa structure du pointeur

Sur les systèmes 64 bits et les environnements d'exécution Objective-C modernes,isa Les pointeurs ont été repensés comme une union plus complexe (union isa_t ), qui contient non seulement des pointeurs vers des objets de classe, mais également d'autres indicateurs et informations permettant d'optimiser l'utilisation de la mémoire et les performances.Ce qui suit estisa_t Un exemple simplifié de structure :

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

Explication du champ de structure

• non-pointeur:instruire isa Qu'il s'agisse d'un type sans pointeur (optimiser la disposition de la mémoire, stocker des informations supplémentaires).
• a_assoc: Indique si l'objet a des références associées (Références Associatives).
• a_cxx_dtor: indique si l'objet a un destructeur C++ et si le destructeur doit être appelé.
• décalagecls: Pointeur de classe, qui stocke les informations de classe de l'objet (après déplacement et compression).
• la magie: Numéro magique utilisé pour le débogage et la vérification de l'exécution.
• faiblement référencé: Indique si l'objet est pointé par une référence faible.
• désallocation: Indique si l'objet est en cours de libération.
• a_sidetable_rc: Si le décompte de références de l'objet est stocké dans la table auxiliaire (Side Table).
• extra_rc: Comptage de références supplémentaire pour optimiser l'utilisation de la mémoire.

Stockage et gestion des comptages de références

Dans les premières implémentations Objective-C, le décompte de références était généralement stocké directement dans l'objet dans le cadre de la structure de l'objet. Par exemple:

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

Dans les environnements d'exécution Objective-C modernes, le comptage de références s'effectue via isa La structure optimisée des pointeurs et la structure de données auxiliaires Side Table sont gérées.

• Comptage de références en ligne: Les informations de comptage de références partielles sont stockées dans isa Dans les structures optimisées de pointeurs, par ex.extra_rc champ.
• Table d'appoint: lorsque le nombre de références dépasse isa Lorsque la plage qu'un pointeur peut représenter, le décompte de références est stocké dans une structure de données auxiliaire appelée Side Table.

Moderne isa Avantages des pointeurs

• Optimisation de la mémoire: En stockant plus d'informations (telles que les décomptes de références, les indicateurs) dans isa Dans les pointeurs, l'accès aux autres zones mémoire est réduit et les performances sont améliorées.
• Amélioration des performances: Opérations de lecture de mémoire réduites car plus d’informations peuvent être obtenues en une seule lecture de mémoire.
• Des métadonnées plus riches: Peut contenir davantage d'informations d'exécution, contribuant ainsi à améliorer la flexibilité et l'efficacité de l'exécution.

Exemple d'utilisation

Bien que les développeurs n'interagissent souvent pas directement avec isa Les pointeurs interagissent, mais comprendre leur structure est utile pour déboguer et optimiser les performances. Voici un exemple d'utilisation qui affiche le type d'un objet en accédant à ses informations de 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

Résumer

isa Les pointeurs jouent un rôle important dans le runtime Objective-C, du simple pointage vers des objets de classe jusqu'aux complexes modernes.isa_t structure, qui permet d’optimiser l’utilisation de la mémoire et les performances.comprendreisa L'évolution des pointeurs et des structures de mémoire peut nous aider à mieux comprendre le mécanisme d'exécution d'Objective-C et à écrire du code efficace.

J'espère que cet article pourra vous aider à mieux comprendre Objective-C. isa Structure de la mémoire du pointeur. Si vous avez des questions ou des suggestions, veuillez laisser un message pour en discuter.