Kotlin Academy · Aula

Interoperação com C usando cinterop e arquivos .def

Chame bibliotecas C a partir do Kotlin/Native usando a ferramenta cinterop e arquivos de definição.

Interoperação com C usando cinterop e arquivos .def é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Por que interoperar com C?

Kotlin/Native pode chamar bibliotecas C diretamente — sem wrappers JNI e sem uma camada de adaptação. Isso permite usar bibliotecas de sistema da plataforma, drivers de hardware ou qualquer biblioteca compatível com C a partir de código Kotlin compilado para binários nativos.

O arquivo .def

Um arquivo .def descreve a biblioteca C a ser importada. Ele especifica cabeçalhos, o nome da biblioteca e opções opcionais do compilador ou do vinculador. Coloque-o em src/nativeInterop/cinterop/:

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

Registrando a interoperabilidade no Gradle

Faça referência ao arquivo .def no bloco compilations do destino:

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

Executando cinterop

Execute ./gradlew cinteropLibcurlLinuxX64 para gerar um .klib a partir dos cabeçalhos C. As vinculações Kotlin geradas aparecem em build/cinterop/ e são adicionadas automaticamente ao caminho de classes da compilação.

Usando funções C em Kotlin

Após a geração, importe o pacote declarado no arquivo .def e chame as funções C como funções Kotlin. Os tipos de ponteiro são representados 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: memória alocada na pilha

memScoped { } cria um escopo de memória no qual as alocações nativas (alloc(), allocArray()) são liberadas automaticamente quando o bloco termina. Use-o sempre para memória C temporária, a fim de evitar vazamentos.

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

Fixando objetos Kotlin para C

Para passar o endereço de um objeto Kotlin a uma função C (por exemplo, uma função de retorno de chamada), fixe-o com StableRef ou Pinned para impedir que o coletor de lixo o mova:

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

Cadeias de caracteres C e Kotlin

Converta entre String do Kotlin e const char* do C usando:

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

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

Acesso a estruturas

As estruturas C tornam-se classes Kotlin com propriedades. Acesse os campos da estrutura usando o operador de ponto. Aloque estruturas com alloc() dentro de um memScoped { }:

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

Incorporando código C embutido

Para trechos curtos de C, use o bloco cCode no arquivo .def para escrever código C embutido que será compilado com a vinculação:

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

Depurando problemas de interoperabilidade com C

Problemas comuns: cabeçalhos ausentes (verifique headerFilter), opções do vinculador ausentes (adicione linkerOpts), tipos incompatíveis (verifique a API .klib gerada). Ative o modo detalhado do cinterop com -verbose no arquivo def ou na configuração da tarefa do Gradle.

Verificação rápida

Qual é a finalidade de memScoped { } na interoperabilidade entre Kotlin/Native e C?

Resumo: interoperabilidade com C usando cinterop e arquivos .def

Principais conclusões:

O arquivo .def especifica cabeçalhos, opções do vinculador e código C embutido opcional
Registre-o no Gradle usando cinterops { val name by creating { defFile(...) } }
Execute a tarefa do Gradle cinterop<Name><Target> para gerar as vinculações
Use memScoped { } para alocações nativas temporárias
Fixe objetos de longa duração com StableRef; converta cadeias de caracteres com .cstr / .toKString()

Perguntas Frequentes

A aula “Interoperação com C usando cinterop e arquivos .def” é grátis?

Sim — o texto completo de “Interoperação com C usando cinterop e arquivos .def” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Interoperação com C usando cinterop e arquivos .def”?

Chame bibliotecas C a partir do Kotlin/Native usando a ferramenta cinterop e arquivos de definição. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Interoperação com C usando cinterop e arquivos .def”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação
Gerenciamento de memória no Kotlin/Native: o novo MM
Interoperação com C usando cinterop e arquivos .def
Kotlin/WASM: compilação para WebAssembly no navegador

← Voltar para Kotlin Academy