0Pricing
Lua Academy · Leçon

Appeler des fonctions C via FFI

Appelez des fonctions de libc et de bibliothèques partagées personnalisées depuis Lua sans surcharge.

Appeler des fonctions C via FFI est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Appels directs de fonctions C

Une fois déclarées avec ffi.cdef, les fonctions C sont appelées exactement comme des fonctions Lua via l’objet représentant la bibliothèque. Les arguments et les valeurs de retour sont automatiquement convertis.

local ffi = require("ffi")
ffi.cdef[[ double sin(double x); ]]
local m = ffi.load("m")
print(m.sin(math.pi / 2))  -- 1.0

Conversion des types

Par défaut, les nombres Lua deviennent des doubles C. La FFI les convertit automatiquement vers le type du paramètre C déclaré. Les booléens deviennent 0 ou 1. Les chaînes deviennent const char*.

Appeler printf

printf est une fonction C à nombre variable d’arguments. Appelez-la via ffi.C.printf avec des chaînes de format et des arguments.

ffi.cdef[[ int printf(const char *fmt, ...); ]]
ffi.C.printf("Sum: %d\n", 42)

Gestion des valeurs de retour

Les valeurs de retour C sont automatiquement converties en types Lua. Les entiers deviennent des nombres Lua, tandis que char* devient du lightuserdata (utilisez ffi.string pour effectuer la conversion).

ffi.cdef[[ char *getenv(const char *name); ]]
local ptr = ffi.C.getenv("HOME")
if ptr ~= nil then
  print(ffi.string(ptr))
end

ffi.string

ffi.string(ptr, len) convertit un pointeur char* en chaîne Lua. Sans len, la lecture continue jusqu’à l’octet nul.

Gestion des erreurs

Les fonctions C renvoient des codes d’erreur ou définissent errno. Vérifiez explicitement les valeurs de retour. Accédez à errno via ffi.errno().

ffi.cdef[[ int open(const char *path, int flags); ]]
local fd = ffi.C.open("missing.txt", 0)
if fd < 0 then
  print("Error:", ffi.errno())
end

Arguments de type structure

Transmettez les structures C par valeur ou par pointeur. Créez-les avec ffi.new.

ffi.cdef[[
  typedef struct { int x, y; } Point;
  void printPoint(Point p);
]]
local p = ffi.new("Point", {x=3, y=4})
lib.printPoint(p)

Arguments de type pointeur

Transmettez des pointeurs de sortie aux fonctions qui renvoient plusieurs valeurs par l’intermédiaire de paramètres pointeurs.

ffi.cdef[[
  void minmax(double *arr, int n, double *min, double *max);
]]
local arr = ffi.new("double[5]", {5,2,8,1,9})
local mn, mx = ffi.new("double[1]"), ffi.new("double[1]")
lib.minmax(arr, 5, mn, mx)
print(mn[0], mx[0])

Performances des appels FFI

Les appels FFI vers des fonctions C ont une surcharge quasi nulle, ce qui les rend bien plus rapides que les appels de Lua vers C via l’API C traditionnelle. Le JIT peut souvent intégrer entièrement l’appel.

Fonctions à nombre variable d’arguments

Les fonctions C à nombre variable d’arguments (...) doivent être appelées avec les types corrects. Si nécessaire, transmettez des conversions de type explicites pour éviter toute ambiguïté.

ffi.C.printf("%d %f\n", ffi.cast("int", 42), ffi.cast("double", 3.14))

Pratiques de sécurité

Vérifiez toujours que les valeurs de retour de type pointeur ne sont pas NULL. Ne transmettez jamais un pointeur libéré ou hors de portée. Utilisez ffi.gc pour associer des finaliseurs aux allocations C.

Question sur les appels FFI

Comment la FFI convertit-elle une chaîne Lua en const char* C ?

Récapitulatif : appeler C via la FFI

Appelez les fonctions C via l’objet représentant la bibliothèque, comme des fonctions Lua. La FFI gère la conversion des types. Utilisez ffi.string pour les valeurs de retour char*, ffi.errno() pour les erreurs et ffi.new pour les arguments de type structure ou tableau.

Questions Fréquemment Posées

La leçon « Appeler des fonctions C via FFI » est-elle gratuite ?

Oui — le texte complet de « Appeler des fonctions C via FFI » 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 Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Appeler des fonctions C via FFI » ?

Appelez des fonctions de libc et de bibliothèques partagées personnalisées depuis Lua sans surcharge. Tu pratiques Lua 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 Lua Academy ?

Aucune expérience préalable n'est requise. Lua 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 2 sur 4.

Combien de temps prend la leçon « Appeler des fonctions C via FFI » ?

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 Lua Academy ?

Oui. Chaque leçon Lua 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

  1. Notions de base sur FFI : ffi.cdef et ffi.load
  2. Appeler des fonctions C via FFI
  3. Pointeurs, structures et tableaux en FFI
  4. Fonctions de rappel : transmettre des fonctions Lua à C
← Retour à Lua Academy