0Pricing
Lua Academy · Leçon

Pointeurs, structures et tableaux en FFI

Manipulez des pointeurs C, des types struct et des allocations de tableaux en FFI.

Pointeurs, structures et tableaux en FFI est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Types C dans la FFI

La FFI prend en charge tous les types C standard : int, float, double, char, les pointeurs, les tableaux et les structures. Déclarez-les dans ffi.cdef.

Créer des tableaux C

Allouez un tableau C avec ffi.new("type[N]"). Accédez aux éléments avec un index commençant à 0, conformément à la convention C.

local ffi = require("ffi")
local arr = ffi.new("int[5]", {10, 20, 30, 40, 50})
print(arr[0], arr[1], arr[4])  -- 10  20  50

Pointeurs

Créez un pointeur vers une valeur ou allouez des types pointeurs. Utilisez ptr[0] pour déréférencer le pointeur.

local ffi = require("ffi")
local p = ffi.new("int[1]", 42)  -- int* pointing to 42
print(p[0])   -- 42
p[0] = 99
print(p[0])   -- 99

Définir et utiliser une structure

Déclarez une structure dans cdef, puis créez des instances avec ffi.new et accédez aux champs avec la notation par points.

ffi.cdef[[
  typedef struct {
    float x, y, z;
  } Vec3;
]]
local v = ffi.new("Vec3", 1.0, 2.0, 3.0)
print(v.x, v.y, v.z)

Tableau de structures

Créez des tableaux de structures pour traiter des données en bloc, une pratique courante dans les moteurs de jeu et le calcul numérique.

local particles = ffi.new("Vec3[1000]")
for i = 0, 999 do
  particles[i].x = i * 0.1
  particles[i].y = 0
  particles[i].z = 0
end

Arithmétique des pointeurs

Faites avancer un pointeur avec ptr + n. Cela renvoie un nouveau pointeur décalé de n éléments, et non de n octets.

local arr = ffi.new("int[5]", {1,2,3,4,5})
local p = arr + 2   -- pointer to arr[2]
print(p[0])         -- 3

ffi.cast : conversion de type

ffi.cast(ctype, val) réinterprète une valeur comme un autre type C. Utilisez cette fonction avec prudence : des conversions incorrectes provoquent un comportement indéfini.

local ffi = require("ffi")
local i = ffi.cast("int32_t", -1)
print(i)  -- -1
local u = ffi.cast("uint32_t", i)
print(u)  -- 4294967295

ffi.sizeof et ffi.alignof

ffi.sizeof("Vec3") renvoie la taille en octets d’un type C. ffi.alignof renvoie son exigence d’alignement.

ffi.gc : associer des finaliseurs

ffi.gc(ptr, cleanup) associe une fonction Lua à un pointeur C afin qu’elle soit appelée lorsque le pointeur est récupéré par le GC, ce qui permet d’appliquer RAII à la mémoire C.

local p = ffi.gc(ffi.C.malloc(1024), ffi.C.free)
-- p is automatically freed when GC collects it

Vérifier les pointeurs nuls

Comparez les pointeurs à nil (qui est égal au pointeur C NULL lors des comparaisons avec la FFI).

local ptr = lib.allocate()
if ptr == nil then error("allocation failed") end

Performances des tableaux C

Les tableaux C accessibles via la FFI sont nettement plus rapides que les tables Lua pour les données numériques : aucun boxing, aucune recherche par hachage et aucune vérification de type.

Question sur les tableaux FFI

Quel index la FFI utilise-t-elle pour les tableaux C ?

Récapitulatif : pointeurs, structures et tableaux avec la FFI

Créez des tableaux C avec ffi.new("type[N]") (indexation à partir de 0), accédez aux champs des structures avec la notation par points, utilisez ffi.cast pour réinterpréter les types et ffi.gc pour nettoyer automatiquement la mémoire C.

Questions Fréquemment Posées

La leçon « Pointeurs, structures et tableaux en FFI » est-elle gratuite ?

Oui — le texte complet de « Pointeurs, structures et tableaux en 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 « Pointeurs, structures et tableaux en FFI » ?

Manipulez des pointeurs C, des types struct et des allocations de tableaux en FFI. 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 3 sur 4.

Combien de temps prend la leçon « Pointeurs, structures et tableaux en 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