Interagire con le classi C ++ di Swift

Ho una significativa libreria di classi scritte in C ++. Sto cercando di utilizzarli attraverso un qualche tipo di bridge all'interno di Swift piuttosto che riscriverli come codice Swift. La motivazione principale è che il codice C ++ rappresenta una libreria di base utilizzata su più piattaforme. In effetti, sto solo creando un'interfaccia utente basata su Swift per consentire alle funzionalità principali di funzionare con OS X.

Ci sono altre domande che chiedono: "Come posso chiamare una funzione C ++ da Swift". Questa non è la mia domanda. Per collegare una funzione C ++, funziona bene quanto segue:

Definisci un'intestazione di bridging tramite "C"

#ifndef ImageReader_hpp
#define ImageReader_hpp

#ifdef __cplusplus
extern "C" {
#endif

    const char *hexdump(char *filename);
    const char *imageType(char *filename);

#ifdef __cplusplus
}
#endif

#endif /* ImageReader_hpp */

Il codice Swift ora può chiamare direttamente le funzioni

let type = String.fromCString(imageType(filename))
let dump = String.fromCString(hexdump(filename))

La mia domanda è più specifica. Come posso creare un'istanza e manipolare una classe C ++ da Swift? Non riesco a trovare nulla di pubblicato su questo.

Ho elaborato una risposta perfettamente gestibile. Quanto pulito vorresti che fosse questo dipende interamente da quanto lavoro sei disposto a fare.

Per prima cosa, prendi la tua classe C ++ e crea funzioni C "wrapper" per interfacciarla con essa. Ad esempio, se abbiamo questa classe C ++:

class MBR {
    std::string filename;

public:
    MBR (std::string filename);
    const char *hexdump();
    const char *imageType();
    const char *bootCode();
    const char *partitions();
private:
    bool readFile(unsigned char *buffer, const unsigned int length);
};

Quindi implementiamo queste funzioni C ++:

#include "MBR.hpp"

using namespace std;
const void * initialize(char *filename)
{
    MBR *mbr = new MBR(filename);

    return (void *)mbr;
}

const char *hexdump(const void *object)
{
    MBR *mbr;
    static char retval[2048];

    mbr = (MBR *)object;
    strcpy(retval, mbr -> hexdump());
    return retval;
}

const char *imageType(const void *object)
{
    MBR *mbr;
    static char retval[256];

    mbr = (MBR *)object;
    strcpy(retval, mbr -> imageType());
    return retval;
}

L'intestazione del bridge contiene quindi:

#ifndef ImageReader_hpp
#define ImageReader_hpp

#ifdef __cplusplus
extern "C" {
#endif

    const void *initialize(char *filename);
    const char *hexdump(const void *object);
    const char *imageType(const void *object);

#ifdef __cplusplus
}
#endif

#endif /* ImageReader_hpp */

Da Swift, ora possiamo istanziare l'oggetto e interagire con esso in questo modo:

let cppObject = UnsafeMutablePointer<Void>(initialize(filename))
let type = String.fromCString(imageType(cppObject))
let dump = String.fromCString(hexdump(cppObject))                
self.imageTypeLabel.stringValue = type!
self.dumpDisplay.stringValue = dump!

Quindi, come puoi vedere, la soluzione (che in realtà è piuttosto semplice) è creare wrapper che istanzeranno un oggetto e restituiranno un puntatore a quell'oggetto. Questo può quindi essere ritrasmesso alle funzioni wrapper che possono facilmente trattarlo come un oggetto conforme a quella classe e chiamare le funzioni membro.

Rendendolo più pulito

Anche se questo è un inizio fantastico e dimostra che è completamente fattibile utilizzare le classi C ++ esistenti con un ponte banale, può essere ancora più pulito.

Ripulirlo significherebbe semplicemente che rimuoviamo UnsafeMutablePointer<Void>dal centro del nostro codice Swift e lo incapsuliamo in una classe Swift. Essenzialmente, usiamo le stesse funzioni wrapper C / C ++ ma le interfacciamo con una classe Swift. La classe Swift mantiene il riferimento all'oggetto e essenzialmente passa tutte le chiamate di riferimento ai metodi e agli attributi attraverso il bridge all'oggetto C ++!

Fatto ciò, tutto il codice bridging è completamente incapsulato nella classe Swift. Anche se stiamo ancora utilizzando un bridge C, stiamo effettivamente utilizzando oggetti C ++ in modo trasparente senza dover ricorrere a ricodificarli in Objective-C o Objective-C ++.

Swift non ha attualmente l'interoperabilità C ++. È un obiettivo a lungo termine, ma è molto improbabile che accada nel prossimo futuro.

Oltre alla tua soluzione, c'è un altro modo per farlo. Puoi chiamare o scrivere direttamente codice C ++ in Objective-C ++.

Quindi puoi creare un wrapper C ++ obiettivo sopra il tuo codice C ++ e creare un'interfaccia adatta.

Quindi chiama il codice Object-C ++ dal tuo codice swift. Per poter scrivere codice Object-C ++ potrebbe essere necessario rinominare l'estensione del file da .m a .mm

Non dimenticare di rilasciare la memoria allocata dai tuoi oggetti C ++ quando opportuno.

Puoi utilizzare Scapix Language Bridge per collegare automaticamente C ++ a Swift (tra le altre lingue). Codice Bridge generato automaticamente al volo direttamente dai file di intestazione C ++. Ecco un esempio :

C ++:

#include <scapix/bridge/object.h>

class contact : public scapix::bridge::object<contact>
{
public:
    std::string name();
    void send_message(const std::string& msg, std::shared_ptr<contact> from);
    void add_tags(const std::vector<std::string>& tags);
    void add_friends(std::vector<std::shared_ptr<contact>> friends);
};

Swift:

class ViewController: UIViewController {
    func send(friend: Contact) {
        let c = Contact()

        contact.sendMessage("Hello", friend)
        contact.addTags(["a","b","c"])
        contact.addFriends([friend])
    }
}

Come un'altra risposta menzionata, usare ObjC ++ per interagire è molto più semplice. Basta nominare i tuoi file .mm invece di .m e xcode / clang, ti dà accesso a c ++ in quel file.

Nota che ObjC ++ non supporta l'ereditarietà C ++. Se vuoi creare una sottoclasse di una classe C ++ in ObjC ++, non puoi. Dovrai scrivere la sottoclasse in C ++ e avvolgerla attorno a una classe ObjC ++.

Quindi usa l'intestazione di bridging che useresti normalmente per chiamare objc da swift.