Comment créer un UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>

Je travaille avec une API C de Swift et de l'une des méthodes que j'ai besoin d'appeler j'ai besoin de donner un

UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>

Plus D'Infos:

Swift Interface:

public func presage_predict(prsg: presage_t, _ result: UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>) -> presage_error_code_t

C D'Origine:

presage_error_code_t presage_predict(presage_t prsg, char*** result);

Quelle est la fonction C déclarés et que fait-il?
Swift Interface: public func presage_predict(ld: presage_t, _ résultat: UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>) -> presage_error_code_t C: presage_error_code_t presage_predict (presage_t ld, char*** result);
semble que vous ont essayé d'utiliser le présage de la bibliothèque à des fins de prédiction. Je suis en train de le construire sur xcode mais arriver a échoué. pourriez-vous m'apprendre comment vous avez fait ?

InformationsquelleAutor Nykholas | 2015-09-21

13

Généralement, si une fonction prend un UnsafePointer<T> paramètre
ensuite, vous pouvez passer une variable de type T comme dans "inout" paramètre avec &. Dans votre cas, T est
```
UnsafeMutablePointer<UnsafeMutablePointer<Int8>>
```
qui est le Swift de cartographie de char **. Vous pouvez donc appeler la fonction C
comme
```
var prediction : UnsafeMutablePointer<UnsafeMutablePointer<Int8>> = nil
if presage_predict(prsg, &prediction) == PRESAGE_OK { ... }
```
À partir de la documentation et des exemples de code du Présage de la bibliothèque, je
comprendre qu'il alloue un tableau de chaînes de caractères et affecte le
l'adresse de ce tableau à la variable pointée par prediction.
Pour éviter une fuite de mémoire, ces chaînes ont à être libéré suite
avec
```
presage_free_string_array(prediction)
```
De démontrer que cela fonctionne réellement, j'ai pris le premier
partie de la démo de code à presage_c_demo.c et traduit
Swift:
```
//Duplicate the C strings to avoid premature deallocation:
let past = strdup("did you not sa")
let future = strdup("")

func get_past_stream(arg: UnsafeMutablePointer<Void>) -> UnsafePointer<Int8> {
    return UnsafePointer(past)
}

func get_future_stream(arg: UnsafeMutablePointer<Void>) -> UnsafePointer<Int8> {
    return UnsafePointer(future)
}

var prsg = presage_t()
presage_new(get_past_stream, nil, get_future_stream, nil, &prsg)

var prediction : UnsafeMutablePointer<UnsafeMutablePointer<Int8>> = nil
if presage_predict(prsg, &prediction) == PRESAGE_OK {

    for var i = 0; prediction[i] != nil; i++ {
        //Convert C string to Swift `String`:
        let pred = String.fromCString(prediction[i])!
        print ("prediction[\(i)]: \(pred)")
    }

    presage_free_string_array(prediction)
}

free(past)
free(future)
```
Ce réellement travaillé et produit la sortie
```
de prédiction[0]: dire 
prédiction[1]: dit 
prédiction[2]: les sauvages 
prédiction[3]: vu 
prédiction[4]: sat 
prédiction[5]: même 
```
- Je pense que vous avez raté un UnsafeMutablePointer dans la prédiction de la déclaration aussi j'ai eu l'erreur suivante pour la conversion de chaîne de caractères: Impossible de convertir une valeur de type 'UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>" attendu argument de type 'UnsafePointer<CChar>' aka UnsafePointer<Int8> aussi la prédiction n'est pas un tableau
- Je suis assez sûr que je ne manque pas un pointeur. J'ai compilé le code contre le présage des en-têtes et n'a obtenu aucune des avertissements ou des erreurs.
- J'ai ajouté plus d'informations et des exemples de code, de l'espoir, qui permet de.
- ouais, ça compile, mais je pense est faux, parce que la prédiction de la signature incorrecte. vous avez dit que c'est un char** au lieu d'un char*** (selon l'en-tête) et, de nouveau, la prédiction ne semble pas être un tableau à tous. Je copie-collé votre code et il ne pénètre jamais dans le cycle: (lldb) fr v prédiction[0] erreur: "(Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<Swift.Int8>>) prédiction" n'est pas un tableau de type
- Très étrange, il compile et s'exécute pour moi, la production de l'montré des résultats, pas des erreurs ou des avertissements.
- Je n'ai pas dit que la fonction prend un char ** paramètre. Il faut un char ***, qui est un pointeur vers une char **.
- en fait, vous avez absolument raison.
- chose étrange, il ne fonctionne pas exactement ce que vous avez mis.J'ai eu une erreur: Un C pointeur de fonction ne peut être formée à partir d'une référence à un func ou un littéral de fermeture, mais j'ai passé la chaîne comme arguments et puis l'obtention de la fermeture et cela a fonctionné!
InformationsquelleAutor Martin R
3

Il peut y avoir une meilleure façon, mais cela va dans l'aire de jeux et définit une valeur r avec le type que vous souhaitez:
```
func ptrFromAddress<T>(p:UnsafeMutablePointer<T>) -> UnsafeMutablePointer<T>
{
   return p
}

var myInt:Int8 = 0
var p = ptrFromAddress(&myInt)
var q = ptrFromAddress(&p)
var r = ptrFromAddress(&q)
```
Quel est le point de la définition de ptrFromAddress, qui semble comme il ne fait rien? Ma pensée est que la section de la Swift interop livre qui traite mutable pointeurs montre de nombreuses façons de les initialiser par le passage d'une expression comme argument (comme &x), mais ne semble pas montrer les moyens correspondants, où il vous suffit d'appeler UnsafeMutablePointer's initialiseur. Donc, nous allons définir un no-op de la fonction juste à utiliser ces méthodes d'initialisation basé sur l'argument de passage de

Mise à jour:

Même si je crois que la méthode ci-dessus est correcte, il a été souligné par @alisoftware dans un autre forum que cela semble être un moyen plus sûr et plus idiomatiques façon de faire la même chose:
```
var myInt: Int8 = 0
withUnsafeMutablePointer(&myInt) { (var p) in
  withUnsafeMutablePointer(&p) { (var pp) in
    withUnsafeMutablePointer(&pp) { (var ppp) in
      //Do stuff with ppp which is a UnsafeMutablePointer<UnsafeMutablePointer<UnsafeMutablePointer<Int8>>>
    }
  }
}
```
C'est plus idiomatique parce que vous êtes à l'aide de la fonction withUnsafeMutablePointer qui est fourni par le Swift de la bibliothèque standard, plutôt que de définir votre propre helper. Il est plus sûr parce que vous avez la garantie que le UnsafeMutablePointer est seulement vivant au cours de la mesure de l'appel à la fermeture (à condition que la fermeture elle-même ne pas stocker le pointeur).

InformationsquelleAutor algal

Vous devez vous connecter pour publier un commentaire.

Mise à jour: