0Pricing
Assembly Language & x86 Low-Level Systems Programming · Leçon

Mémoire dynamique : allocation du tas en assembleur

Demandez et libérez de la mémoire à l’exécution depuis l’assembleur en utilisant les interfaces du tas de l’OS (brk/mmap sous Linux, VirtualAlloc sous Windows) ainsi que malloc/free de la bibliothèque C.

Mémoire dynamique : allocation du tas en assembleur est une leçon Assembly Language & x86 Low-Level Systems Programming gratuite sur CoddyKit. Ceci est la leçon 4 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 Assembly Language & x86 Low-Level Systems Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Assembly Language & x86 Low-Level Systems Programming comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Stack vs Heap

The stack holds fixed, scope-bound data and is automatically reclaimed. The heap provides dynamic memory whose size and lifetime you control at run time.

When You Need the Heap

Use heap memory when the size is unknown at assemble time or the data must outlive the procedure that created it, e.g. growing buffers and data structures.

Linux: the brk Syscall

The brk/sbrk syscall grows the programs data segment. It is low level and mostly superseded by mmap for general allocation.

mov rax, 12     ; sys_brk
mov rdi, 0
syscall

Linux: mmap

mmap maps fresh anonymous pages and is the modern way to get large heap regions directly from the kernel.

mov rax, 9      ; sys_mmap
syscall

Releasing with munmap

Memory obtained from mmap is returned with munmap, telling the kernel those pages are free.

mov rax, 11     ; sys_munmap
syscall

Windows: VirtualAlloc

On Windows you call VirtualAlloc to reserve and commit pages, and VirtualFree to release them.

call VirtualAlloc

Using the C Library

When linking with the C runtime, it is far simpler to call malloc and free, which manage a heap on top of the OS primitives.

mov rdi, 64     ; bytes
call malloc

Checking the Result

Allocation can fail. malloc returns NULL and syscalls return a negative error code, so always test the result before using the pointer.

test rax, rax
jz alloc_failed

Freeing Memory

Every allocation needs a matching free. Forgetting to free leaks memory; freeing twice or using freed memory corrupts the heap.

mov rdi, rax    ; pointer
call free

Alignment Considerations

Heap blocks are returned suitably aligned for any type. Manual allocators must respect alignment for SSE and atomic operations.

Common Pitfalls

Heap bugs are subtle:

  • Memory leaks from missing free
  • Use-after-free
  • Double free
  • Buffer overruns past the allocation

Quick Check

Test your understanding of heap allocation.

Recap

You learned heap allocation:

  • Stack is automatic; heap is run-time managed
  • Linux: mmap/munmap or brk
  • Windows: VirtualAlloc/VirtualFree
  • With libc use malloc/free; always check for NULL and free once

Questions Fréquemment Posées

La leçon « Mémoire dynamique : allocation du tas en assembleur » est-elle gratuite ?

Oui — le texte complet de « Mémoire dynamique : allocation du tas en assembleur » 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 Assembly Language & x86 Low-Level Systems Programming, passe à CoddyKit PRO. Le cours Assembly Language & x86 Low-Level Systems Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mémoire dynamique : allocation du tas en assembleur » ?

Demandez et libérez de la mémoire à l’exécution depuis l’assembleur en utilisant les interfaces du tas de l’OS (brk/mmap sous Linux, VirtualAlloc sous Windows) ainsi que malloc/free de la bibliothèqu… Tu pratiques Assembly Language & x86 Low-Level Systems Programming 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 Assembly Language & x86 Low-Level Systems Programming ?

Aucune expérience préalable n'est requise. Assembly Language & x86 Low-Level Systems Programming 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 4 sur 4.

Combien de temps prend la leçon « Mémoire dynamique : allocation du tas en assembleur » ?

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 Assembly Language & x86 Low-Level Systems Programming ?

Oui. Chaque leçon Assembly Language & x86 Low-Level Systems Programming 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. Concepts de la mémoire virtuelle
  2. Appels système Linux (syscalls)
  3. Interaction avec l’API Windows
  4. Mémoire dynamique : allocation du tas en assembleur
← Retour à Assembly Language & x86 Low-Level Systems Programming