Lua Academy · Lektion

Callbacks: skicka Lua-funktioner till C

Använd ffi.cast för att skapa C-callbacks som anropar Lua-kod.

Lektion 4 av 413 steg

Callbacks: skicka Lua-funktioner till C är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad är C-callbacks?

Vissa C-API:er kräver att du skickar en funktionspekare som C-koden anropar senare. FFI:s ffi.cast låter dig skapa C-kompatibla funktionspekare från Lua-funktioner.

Deklarera en callbacktyp

Deklarera först funktionspekartypen i cdef.

local ffi = require("ffi")
ffi.cdef[[
  typedef void (*callback_t)(int event, void *data);
  void register_handler(callback_t cb);
]]

Skapa en callback

Använd ffi.cast("callback_t", luaFunc) för att omsluta en Lua-funktion som en C-callback. Resultatet är en C-funktionspekare som kan skickas till C-kod.

local function myHandler(event, data)
  print("Event:", event)
end
local cb = ffi.cast("callback_t", myHandler)
lib.register_handler(cb)

Callbackens livslängd

Behåll en Lua-referens till callback-objektet (cb). Om det samlas in av GC kraschar ett anrop av C-funktionspekaren. Lagra det i en långlivad variabel eller tabell.

local callbacks = {}  -- prevent GC
callbacks[#callbacks+1] = ffi.cast("callback_t", myHandler)
lib.register_handler(callbacks[#callbacks])

Sortera med en C-komparator

Skicka en Lua-komparator till C:s qsort via en FFI-callback.

ffi.cdef[[
  typedef int (*cmp_t)(const void *a, const void *b);
  void qsort(void *base, size_t nmemb, size_t size, cmp_t cmp);
]]
local arr = ffi.new("int[5]", {3,1,4,1,5})
local cmp = ffi.cast("cmp_t", function(a, b)
  return ffi.cast("int*", a)[0] - ffi.cast("int*", b)[0]
end)
ffi.C.qsort(arr, 5, ffi.sizeof("int"), cmp)
for i = 0, 4 do io.write(arr[i] .. " ") end

Callbacks och coroutines

Lua-callbacks som anropas från C kan inte ge upp kontrollen (anropa coroutine.yield). C-sidan stöder inte Luas coroutine-växling. Utforma callbacks så att de inte ger upp kontrollen.

Upvalues i callbacks

Lua-callbacks kan fånga upvalues på vanligt sätt. Då kan callbacks komma åt kontext (t.ex. ett objekt eller en tillståndstabell) utan globala variabler.

local function makeHandler(ctx)
  return ffi.cast("callback_t", function(event, _)
    ctx.lastEvent = event  -- upvalue access
  end)
end

Signalhanterare

Registrera Lua-funktioner som Unix-signalhanterare via FFI. Var försiktig: signalhanterare har strikta begränsningar för vilka C-funktioner de kan anropa.

Minneshantering för callbacks

Frigör callbacks med cb:free() efter att de har avregistrerats på C-sidan. Callback-objekt som läcker förbrukar minne.

Alternativ: C-wrapperfunktioner

För komplexa integrationer kan en tunn C-shim vara renare än FFI-callbacks. Shim:en anropar Lua via C-API:t och ger full kontroll över coroutine- och felhantering.

Prestanda

FFI-callbacks är snabba men inte lika snabba som direkta FFI-anrop, eftersom bryggan från C till Lua medför viss overhead vid initiering. För callbacks med mycket hög frekvens (t.ex. ljud) bör du överväga rena C-implementationer.

Callbackfråga

Varför måste en Lua-referens till ett FFI-callbackobjekt behållas?

Besvara frågan i den interaktiva lektionen

Sammanfattning: FFI-callbacker

Använd ffi.cast("fn_ptr_type", luaFunc) för att skapa C-kompatibla callbacker. Spara alltid en referens för att förhindra GC. Callbacker kan inte använda yield. Använd upvalues för att skicka kontext till callbacker.

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Callbacks: skicka Lua-funktioner till C” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Callbacks: skicka Lua-funktioner till C”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Callbacks: skicka Lua-funktioner till C”?

Använd ffi.cast för att skapa C-callbacks som anropar Lua-kod. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Callbacks: skicka Lua-funktioner till C”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lua Academy