Kotlin Academy · Lección

Interoperabilidad con C mediante cinterop y archivos .def

Llame a bibliotecas de C desde Kotlin/Native utilizando la herramienta cinterop y archivos de definición

Lección 3 de 413 pasos

Interoperabilidad con C mediante cinterop y archivos .def es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Por qué interoperar con C?

Kotlin/Native puede llamar directamente a bibliotecas de C, sin wrappers de JNI ni capa de interoperabilidad. Esto permite utilizar bibliotecas del sistema de la plataforma, controladores de hardware o cualquier biblioteca compatible con C desde código Kotlin compilado en binarios nativos.

El archivo .def

Un archivo .def describe la biblioteca de C que se va a importar. Especifica los encabezados, el nombre de la biblioteca y las marcas opcionales del compilador y del enlazador. Colóquelo en src/nativeInterop/cinterop/:

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

Registrar la interoperabilidad en Gradle

Haga referencia al archivo .def en el bloque compilations del destino:

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

Ejecución de cinterop

Ejecute ./gradlew cinteropLibcurlLinuxX64 para generar un .klib a partir de los encabezados de C. Los enlaces de Kotlin generados aparecen en build/cinterop/ y se añaden automáticamente al classpath de compilación.

Uso de funciones de C en Kotlin

Después de generarlos, importe el paquete declarado en el archivo .def y llame a las funciones de C como si fueran funciones de Kotlin. Los tipos de puntero se representan como 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 asignada en la pila

memScoped { } crea un ámbito de memoria en el que las asignaciones nativas (alloc(), allocArray()) se liberan automáticamente al salir del bloque. Úselo siempre para la memoria C temporal a fin de evitar fugas.

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

Fijación de objetos Kotlin para C

Para pasar la dirección de un objeto de Kotlin a una función de C (por ejemplo, un callback), fíjelo con StableRef o Pinned para evitar que el recolector de basura lo mueva:

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

Cadenas de C y cadenas de Kotlin

Convierta entre String de Kotlin y const char* de C mediante:

"hello".cstr → CValues, válido dentro de memScoped
cPointer.toKString() → una cadena de Kotlin a partir de un CPointer<ByteVar>

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

Acceso a estructuras

Las estructuras de C se convierten en clases de Kotlin con propiedades. Acceda a los campos de una estructura mediante el operador punto. Reserve estructuras con alloc() dentro de un bloque memScoped { }:

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

Incorporación de código C en línea

Para fragmentos cortos de C, use el bloque cCode en el archivo .def para escribir código C en línea que se compila junto con los enlaces:

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

Depuración de problemas de interoperabilidad con C

Problemas comunes: faltan encabezados (compruebe headerFilter), faltan opciones del enlazador (añada linkerOpts) o los tipos no coinciden (compruebe la API del .klib generado). Habilite cinterop detallado con -verbose en el archivo def o en la configuración de la tarea de Gradle.

Comprobación rápida

¿Cuál es el propósito de memScoped { } en la interoperabilidad de Kotlin/Native con C?

Responde en la lección interactiva

Resumen: interoperabilidad con C mediante cinterop y archivos .def

Aspectos clave:

El archivo .def especifica los encabezados, las opciones del enlazador y el código C en línea opcional
Regístrelo en Gradle mediante cinterops { val name by creating { defFile(...) } }
Ejecute la tarea de Gradle cinterop<Name><Target> para generar los enlaces
Use memScoped { } para las asignaciones nativas temporales
Fije los objetos de larga duración con StableRef; convierta las cadenas con .cstr / .toKString()

Gratis para empezar

Aprende Kotlin con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Interoperabilidad con C mediante cinterop y archivos .def» es gratis?

Sí — el texto completo de «Interoperabilidad con C mediante cinterop y archivos .def» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Interoperabilidad con C mediante cinterop y archivos .def»?

Llame a bibliotecas de C desde Kotlin/Native utilizando la herramienta cinterop y archivos de definición Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Interoperabilidad con C mediante cinterop y archivos .def»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Introducción a Kotlin/Native: destinos, cadena de herramientas y compilación
Gestión de memoria en Kotlin/Native: el nuevo MM
Interoperabilidad con C mediante cinterop y archivos .def
Kotlin/WASM: compilación a WebAssembly para el navegador

← Volver a Kotlin Academy