Transmettre un objet Objective-C à une fonction en tant que pointeur void *

J'ai une fonction:

  myFunction (MyProc callback, void * ref)

Cette fonction est appelée à partir d'un Objectif-C de classe. La fonction est passée à un pointeur à la fonction de rappel (une fonction dans la classe) et une référence. La référence est nécessaire parce que la fonction de rappel est appelée de façon statique et donc n'a pas un contexte. L'arbitre peut être utilisé pour fournir un contexte pour le rappel.

Je veux être en mesure de passer à l'Objective-C classe comme référence. La question est donc:

Comment puis-je jeter un NSObject à un void * et comment puis-je jeter un void * comme un NSObject.

Merci d'avance.

source d'informationauteur Ben Smiley | 2012-10-16

32

Faire quelque chose comme ceci:
```
void func(void *q)
{
    NSObject* o = CFBridgingRelease(q);
    NSLog(@"%@", o);
}

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        NSObject* o = [NSObject new];
        func((void*)CFBridgingRetain(o));
    }
    return 0;
}
```
Noter que CFBridgingRetain() et CFBridgingRelease() sont des macros autour de compilateur attributs. N'hésitez pas à utiliser. J'aime l'API variante comme il est plus en usage en commun dans nos bases de codes et il est plus explicitement /moins à confusion.

CFBridgingRetain() effectivement dur conserve l'objet qui doit être équilibrée par un CFBridgingRelease(). Il arrive aussi de revenir un CFTypeRef qui est compatible avec un casting de void*. CFBridgingRelease() efficacement dégrafe que le fait de conserver et, ainsi, q restera seulement valide dans le champ d'application que o est valide.

Valable pour la base des rappels, mais vous auriez probablement pas ce que avec un void *context; type de chose qui doit rester dans les parages pendant un certain temps. Pour qui:
```
void callback(void *context)
{
    //grab an ARC aware reference without impacting hard-retain
    NSObject* o = (__bridge NSObject *)(context);
    NSLog(@"%@", o);
}

void freeContext(void *context)
{
    //release the hard-retain
    CFBridgingRelease(context);
}
```
Noter que Xcode est très bon sur ce qui suggère exactement ce que vous devriez faire si vous laissez de côté le cast /appel d'API. Il explique même les significations de chacune des solutions de rechange (je me suis appuyé sur ce fortement jusqu'à ce que j'ai pu garder 'em droite dans ma tête).
6

Je suppose que vous êtes à l'aide de l'ARC. Vous pouvez utiliser quelque chose comme cela lors de l'appel de myFunction
```
id ref = ...; //your Objective-C object
myFunction(callback, (__bridge_retained void *) ref);
```
Dans votre rappel, vous devez transférer la propriété:
```
void callback(void* refPtr) {
    id refObj = (__bridge_transfer id) refPtr;
}
```
Remplacer id avec votre type d'objet comme les approprier.
1

Réponse: en aucune façon. void * est implicitement compatible avec n'importe quel type de pointeur, donc si vous avez un objet, qui est un pointeur de type id (alias pour struct objc_object *), vous pouvez tout simplement passer à l'endroit où le pointeur est nul besoin, sans moulage. Exemple:
```
//this is the declaration of the callback function:
void callback(void *context);

//then you can call it like this:
SomeClass *obj = [[SomeClass alloc] init];
callback(obj);
```

Vous devez vous connecter pour publier un commentaire.