Kotlin Academy · Leçon

Interopérabilité avec C grâce à cinterop et aux fichiers .def

Appelez des bibliothèques C depuis Kotlin/Native à l’aide de l’outil cinterop et de fichiers de définition.

Interopérabilité avec C grâce à cinterop et aux fichiers .def est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Pourquoi l’interopérabilité avec C ?

Kotlin/Native peut appeler directement les bibliothèques C : aucune enveloppe JNI ni couche d’intermédiation n’est nécessaire. Vous pouvez ainsi utiliser les bibliothèques système de la plateforme, les pilotes matériels ou toute bibliothèque compatible avec C depuis du code Kotlin compilé en binaires natifs.

Le fichier .def

Un fichier .def décrit la bibliothèque C à importer. Il indique les en-têtes, le nom de la bibliothèque et les options facultatives du compilateur et de l’éditeur de liens. Placez-le dans src/nativeInterop/cinterop/ :

# src/nativeInterop/cinterop/libcurl.def
headers = curl/curl.h
headerFilter = curl/**
linkerOpts.linux = -lcurl
linkerOpts.macos = -lcurl

Enregistrer l’interopérabilité dans Gradle

Référencez le fichier .def dans le bloc compilations de la cible :

kotlin {
    linuxX64 {
        compilations["main"].cinterops {
            val libcurl by creating {
                defFile(project.file("src/nativeInterop/cinterop/libcurl.def"))
            }
        }
    }
}

Exécuter cinterop

Exécutez ./gradlew cinteropLibcurlLinuxX64 pour générer un .klib à partir des en-têtes C. Les liaisons Kotlin générées apparaissent dans build/cinterop/ et sont automatiquement ajoutées au chemin de classes de compilation.

Utiliser des fonctions C en Kotlin

Après la génération, importez le paquet déclaré dans le fichier .def et appelez les fonctions C comme des fonctions Kotlin. Les types de pointeurs sont représentés par CPointer :

import libcurl.*
import kotlinx.cinterop.*

fun fetchUrl(url: String): String = memScoped {
    val handle = curl_easy_init() ?: error("curl init failed")
    curl_easy_setopt(handle, CURLOPT_URL, url.cstr.ptr)
    curl_easy_perform(handle)
    curl_easy_cleanup(handle)
    "done"
}

memScoped : mémoire allouée sur la pile

memScoped { } crée une portée mémoire dans laquelle les allocations natives (alloc(), allocArray()) sont automatiquement libérées à la sortie du bloc. Utilisez-le toujours pour la mémoire C temporaire afin d'éviter les fuites.

memScoped {
    val value = alloc<IntVar>()
    value.value = 42
    println(value.value)  // 42
    // freed automatically at end of memScoped
}

Épingler des objets Kotlin pour C

Pour transmettre l'adresse d'un objet Kotlin à une fonction C (par exemple, un rappel), épinglez-le avec StableRef ou Pinned afin d'empêcher le ramasse-miettes de le déplacer :

val stableRef = StableRef.create(myKotlinObject)
try {
    c_function_expecting_user_data(stableRef.asCPointer())
} finally {
    stableRef.dispose()
}

Chaînes C et chaînes Kotlin

Convertissez une String Kotlin et un const char* C l'un vers l'autre avec :

"hello".cstr → CValues, valide dans memScoped
cPointer.toKString() → une String Kotlin à partir d'un CPointer<ByteVar>

memScoped {
    val cStr = "Hello, C!".cstr.ptr   // CPointer<ByteVar>
    val back = cStr.toKString()         // "Hello, C!"
}

Accéder aux structures

Les structures C deviennent des classes Kotlin dotées de propriétés. Accédez aux champs des structures à l'aide de l'opérateur point. Allouez les structures avec alloc() dans un memScoped { } :

memScoped {
    val addr = alloc<sockaddr_in>()
    addr.sin_family = AF_INET.convert()
    addr.sin_port = htons(8080u).convert()
}

Intégrer du code C en ligne

Pour de courts extraits C, utilisez le bloc cCode dans le fichier .def pour écrire du code C en ligne qui sera compilé avec la liaison :

# In .def file
headers = stdio.h
---
// Inline C code after ---
static inline int add(int a, int b) { return a + b; }

Déboguer les problèmes d'interopérabilité C

Problèmes courants : en-têtes manquants (vérifiez headerFilter), options de liaison manquantes (ajoutez linkerOpts), types incompatibles (vérifiez l'API du .klib généré). Activez le mode détaillé de cinterop avec -verbose dans le fichier def ou dans la configuration de la tâche Gradle.

Vérification rapide

À quoi sert memScoped { } dans l'interopérabilité C de Kotlin/Native ?

Récapitulatif : interopérabilité C avec cinterop et les fichiers .def

Points clés :

Le fichier .def spécifie les en-têtes, les options de liaison et le code C en ligne facultatif
Enregistrez-le dans Gradle via cinterops { val name by creating { defFile(...) } }
Exécutez la tâche Gradle cinterop<Name><Target> pour générer les liaisons
Utilisez memScoped { } pour les allocations natives temporaires
Épinglez les objets utilisés sur une longue durée avec StableRef ; convertissez les chaînes avec .cstr / .toKString()

Questions Fréquemment Posées

La leçon « Interopérabilité avec C grâce à cinterop et aux fichiers .def » est-elle gratuite ?

Oui — le texte complet de « Interopérabilité avec C grâce à cinterop et aux fichiers .def » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Interopérabilité avec C grâce à cinterop et aux fichiers .def » ?

Appelez des bibliothèques C depuis Kotlin/Native à l’aide de l’outil cinterop et de fichiers de définition. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Interopérabilité avec C grâce à cinterop et aux fichiers .def » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Présentation de Kotlin/Native : cibles, chaîne d’outils et compilation
Gestion de la mémoire dans Kotlin/Native : le nouveau MM
Interopérabilité avec C grâce à cinterop et aux fichiers .def
Kotlin/WASM : compiler vers WebAssembly pour le navigateur

← Retour à Kotlin Academy