passant soi-même de l'objectif C à C++, pas plus deallocation

Question

J'espère que quelqu'un peut m'aider avec mon problème, recherché longtemps et n'a pas trouvé une réponse suffisante. J'utilise Objective-C++ pour fusionner les classes Objective C et C++ (puisque pour mon projet j'ai besoin d'hériter des classes des deux langages). Ma classe principale est une classe Objective-C et j'ai une petite classe d'aide en C++, qui est passée dans l'objet Objective-C et en appelle des fonctions.

Mon problème est que pendant que cela fonctionne, il n'y a pas de désallocation (ou de déconstruction). Il semble que le fait de passer self dans la classe init de classe Objective-C à la classe C++ crée une sorte de verrou de mémoire ou de fuite lorsque j'essaie d'enregistrer l'objet Objective-C dans une variable de classe dans l'objet C++.

J'utilise ARC.

Voici l'exemple de code:

#import <Foundation/Foundation.h> 

@interface MyObjCClass : NSObject 
@end 

int main(int argc, const char * argv[]) { 
    MyObjCClass *test = [[MyObjCClass alloc] init]; 
    test = nil; 
} 

class MyCppClass { 
public: 
    MyCppClass(void *test); 
    ~MyCppClass(); 

private: 
    void testFunction(); 
    MyObjCClass *myObjCObject; 

}; 


MyCppClass::MyCppClass(void *test){ 
    MyObjCClass *obj = (__bridge MyObjCClass *) test; 
    myObjCObject = obj; //when doing this, there is no more deallocation/deconstruction called 
    NSLog(@"constructing c++ class"); 
} 

MyCppClass::~MyCppClass(){ 
    NSLog(@"deconstructing c++ class"); 
} 

@implementation MyObjCClass { 
    MyCppClass *myCppObject; 
} 

- (instancetype)init 
{ 
    if (self) { 
     NSLog(@"initializing ObjC class"); 
     myCppObject = new MyCppClass((__bridge void *) self); 
    } 
    return self; 
} 

- (void)dealloc 
{ 
    delete myCppObject; 
    NSLog(@"deallocating ObjC class"); 
} 

@end 

Answer 1

Dans

MyCppClass::MyCppClass(void *test){ 
    MyObjCClass *obj = (__bridge MyObjCClass *) test; 
    myObjCObject = obj; // <-- Creates a strong reference 
    NSLog(@"constructing c++ class"); 
} 

une forte référence à l'objet est créé, et qui empêche d'être désallouée l'objet . Une solution possible est d'utiliser à la place d'une référence faible :

class MyCppClass { 
// ...   

private: 
    void testFunction(); 
    __weak MyObjCClass *myObjCObject; // <-- Weak reference 

}; 

Le pointeur faible est réglée sur nil lorsque l'objet est désalloué.

Pour plus d'informations, voir Use Weak References to Avoid Retain Cycles dans le "Guide avancé de programmation de gestion de la mémoire".