Kotlin Academy · Lezione

Interop con C tramite cinterop e file .def

Chiami librerie C da Kotlin/Native utilizzando lo strumento cinterop e i file di definizione.

Interop con C tramite cinterop e file .def è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Perché l'interoperabilità con C?

Kotlin/Native può chiamare direttamente le librerie C: non servono wrapper JNI né un layer di bridging. Questo consente di utilizzare librerie di sistema della piattaforma, driver hardware o qualsiasi libreria compatibile con C dal codice Kotlin compilato in binari nativi.

Il file .def

Un file .def descrive la libreria C da importare. Specifica gli header, il nome della libreria e, facoltativamente, i flag del compilatore e del linker. Lo collochi in src/nativeInterop/cinterop/:

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

Registrare l'interoperabilità in Gradle

Faccia riferimento al file .def nel blocco compilations del target:

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

Esecuzione di cinterop

Esegua ./gradlew cinteropLibcurlLinuxX64 per generare un .klib dalle intestazioni C. I binding Kotlin generati vengono inseriti in build/cinterop/ e aggiunti automaticamente al classpath della compilazione.

Utilizzo delle funzioni C in Kotlin

Dopo la generazione, importi il package dichiarato nel file .def e chiami le funzioni C come funzioni Kotlin. I tipi puntatore sono rappresentati come 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: memoria allocata nello stack

memScoped { } crea un ambito di memoria in cui le allocazioni native (alloc(), allocArray()) vengono liberate automaticamente quando si esce dal blocco. Lo utilizzi sempre per la memoria C temporanea, così da evitare perdite di memoria.

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

Fissare gli oggetti Kotlin per C

Per passare l'indirizzo di un oggetto Kotlin a una funzione C, ad esempio una callback, lo fissi con StableRef o Pinned per impedire al GC di spostarlo:

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

Stringhe C e stringhe Kotlin

Converta tra String di Kotlin e const char* di C utilizzando:

"hello".cstr → CValues, valido all'interno di memScoped
cPointer.toKString() → una stringa Kotlin ottenuta da un CPointer<ByteVar>

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

Accesso alle struct

Le struct C diventano classi Kotlin con proprietà. Acceda ai campi delle struct utilizzando l'operatore punto. Allochi le struct con alloc() all'interno di un memScoped { }:

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

Incorporare codice C inline

Per brevi frammenti C, utilizzi il blocco cCode nel file .def per scrivere codice C inline, che viene compilato insieme al binding:

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

Debug dei problemi di interoperabilità C

Problemi comuni: intestazioni mancanti (controlli headerFilter), flag del linker mancanti (aggiunga linkerOpts), tipi non corrispondenti (controlli l'API del .klib generato). Abiliti l'output dettagliato di cinterop con -verbose nel file def o nella configurazione del task Gradle.

Verifica rapida

Qual è lo scopo di memScoped { } nell'interoperabilità C di Kotlin/Native?

Riepilogo: interoperabilità C con cinterop e file .def

Punti chiave:

Il file .def specifica le intestazioni, le opzioni del linker e l'eventuale codice C inline
Registri l'interoperabilità in Gradle tramite cinterops { val name by creating { defFile(...) } }
Esegua il task Gradle cinterop<Name><Target> per generare i binding
Utilizzi memScoped { } per le allocazioni native temporanee
Fissi gli oggetti di lunga durata con StableRef; converta le stringhe con .cstr / .toKString()

Domande Frequenti

La lezione «Interop con C tramite cinterop e file .def» è gratuita?

Sì — il testo completo di «Interop con C tramite cinterop e file .def» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Interop con C tramite cinterop e file .def»?

Chiami librerie C da Kotlin/Native utilizzando lo strumento cinterop e i file di definizione. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Interop con C tramite cinterop e file .def»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Panoramica di Kotlin/Native: target, toolchain e compilazione
Gestione della memoria in Kotlin/Native: il nuovo MM
Interop con C tramite cinterop e file .def
Kotlin/WASM: compilazione in WebAssembly per il browser

← Torna a Kotlin Academy