๐ Retour au Sommaire
Tout programmeur C a commencรฉ par รฉcrire ce programme :
#include <stdio.h>
int main(void) {
printf("Hello, World!\n");
return 0;
}
Ces quelques lignes semblent simples, mais elles cachent une machinerie complexe. Dans cette section, nous allons dรฉcortiquer entiรจrement ce programme pour comprendre ce qui se passe rรฉellement, de la compilation jusquโร lโaffichage du texte ร lโรฉcran.
Prรฉparez-vous ร dรฉcouvrir que mรชme le plus simple des programmes est une merveille dโingรฉnierie !
Reprenons notre programme et examinons chaque ligne en dรฉtail.
#include <stdio.h>#include <stdio.h>
Que fait cette ligne ?
Cโest une directive de prรฉprocesseur. Elle demande au prรฉprocesseur dโinsรฉrer le contenu du fichier stdio.h ร cet endroit.
Quโest-ce que stdio.h ?
stdio = Standard Input/Output (Entrรฉes/Sorties standard).h = fichier dโen-tรชte (header)printf, scanf, fopen, etc.Pourquoi est-ce nรฉcessaire ?
En C, vous devez dรฉclarer une fonction avant de lโutiliser. Sans #include <stdio.h>, le compilateur ne connaรฎtrait pas printf et afficherait une erreur (ou un warning selon la version).
Les chevrons < > vs guillemets " "
#include <stdio.h> // Cherche dans les rรฉpertoires systรจme
#include "monfichier.h" // Cherche d'abord dans le rรฉpertoire courant
int main(void)int main(void)
Que reprรฉsente cette ligne ?
Cโest la dรฉclaration de la fonction main, le point dโentrรฉe de tout programme C.
Dรฉcomposition :
| รlรฉment | Signification |
|---|---|
int |
Type de retour : la fonction renvoie un entier |
main |
Nom de la fonction (imposรฉ, pas de choix) |
void |
La fonction ne prend aucun paramรจtre |
Pourquoi main est-elle spรฉciale ?
mainVariantes de main :
int main(void) // Sans arguments
int main(int argc, char *argv[]) // Avec arguments de ligne de commande
int main(int argc, char **argv) // รquivalent
{{
Marque le dรฉbut du corps de la fonction main. Tout le code entre { et } appartient ร cette fonction.
printf("Hello, World!\n"); printf("Hello, World!\n");
Cโest le cลur de notre programme. Analysons-le en dรฉtail.
printf : Fonction de la bibliothรจque standard C qui affiche du texte formatรฉ.
"Hello, World!\n" : Une chaรฎne de caractรจres (string literal).
Le \n : Un caractรจre dโรฉchappement reprรฉsentant un saut de ligne (newline).
Le ; : Termine lโinstruction (obligatoire en C).
Les caractรจres dโรฉchappement courants :
| Sรฉquence | Signification |
|---|---|
\n |
Nouvelle ligne (newline) |
\t |
Tabulation |
\\ |
Antislash littรฉral |
\" |
Guillemet double |
\0 |
Caractรจre nul (fin de chaรฎne) |
return 0; return 0;
Que fait cette ligne ?
main0 au systรจme dโexploitationQue signifie la valeur de retour ?
| Valeur | Signification conventionnelle |
|---|---|
0 |
Succรจs, tout sโest bien passรฉ |
!= 0 |
Erreur (le code indique le type dโerreur) |
Comment vรฉrifier cette valeur ?
./hello
echo $? # Affiche le code de retour du dernier programme
# Rรฉsultat : 0
}}
Marque la fin du corps de la fonction main.
Rappelons les 4 รฉtapes de la compilation et voyons ce qui arrive ร notre Hello World.
Le prรฉprocesseur remplace #include <stdio.h> par le contenu de ce fichier.
Avant :
#include <stdio.h>
int main(void) {
printf("Hello, World!\n");
return 0;
}
Aprรจs (simplifiรฉ) :
/* Contenu de stdio.h : environ 800 lignes */
typedef struct _IO_FILE FILE;
extern int printf(const char *format, ...);
/* ... des centaines d'autres dรฉclarations ... */
int main(void) {
printf("Hello, World!\n");
return 0;
}
Notre fichier de 7 lignes devient un fichier de ~800 lignes !
Le compilateur transforme le code C en assembleur :
.file "hello.c"
.section .rodata
.LC0:
.string "Hello, World!"
.text
.globl main
.type main, @function
main:
pushq %rbp
movq %rsp, %rbp
leaq .LC0(%rip), %rdi
call puts@PLT
movl $0, %eax
popq %rbp
ret
Observations intรฉressantes :
"Hello, World!" est stockรฉe dans .rodata (donnรฉes en lecture seule)\n a disparu car GCC a optimisรฉ printf("...\n") en puts("...")return 0 devient movl $0, %eax (la valeur de retour est placรฉe dans le registre eax)Lโassembleur convertit le code assembleur en code machine (binaire).
gcc -c hello.c -o hello.o
hexdump -C hello.o | head -5
# 00000000 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 |.ELF............|
Le fichier commence par 7f 45 4c 46 qui correspond ร .ELF โ le format des exรฉcutables Linux.
Le linker assemble notre code avec la bibliothรจque C standard pour crรฉer lโexรฉcutable final.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ รDITION DE LIENS DU HELLO WORLD โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ hello.o libc.so.6 โ
โ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ main: โ โ printf: โโโโโโโโโโโโโผโโโ โ
โ โ call puts โโโโโผโโโโโโโโถโ puts: โ โ โ โ
โ โ movl $0, %eax โ โ exit: โ โ โ โ
โ โโโโโโโโโโโโโโโโโโโ โ _start: โ โ โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโ โ โ
โ โ โ
โ ld-linux.so โ โ
โ (chargeur dynamique) โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโ โ โ
โ โ Rรฉsout les symboles โโโโ โ
โ โ au dรฉmarrage โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ hello โ โ
โ โ (exรฉcutable) โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Quand vous tapez ./hello et appuyez sur Entrรฉe, une sรฉrie dโรฉvรฉnements se produit.
Votre shell (bash, zsh, etc.) lit ./hello et comprend que vous voulez exรฉcuter le fichier hello dans le rรฉpertoire courant.
Le shell demande au noyau Linux de crรฉer un nouveau processus via lโappel systรจme fork(), puis de remplacer ce processus par votre programme via execve().
Avant mรชme que main ne sโexรฉcute, le chargeur dynamique (ld-linux.so) :
libc.so.6)puts ร son code dans la libc)Surprise ! main nโest pas la vraie premiรจre fonction exรฉcutรฉe. La libc exรฉcute dโabord du code dโinitialisation :
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ SรQUENCE DE DรMARRAGE RรELLE โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ ./hello โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ _start (point d'entrรฉe ELF) โ โ
โ โ Fourni par la libc (crt1.o) โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ __libc_start_main โ โ
โ โ - Initialise la libc โ โ
โ โ - Configure argc, argv, envp โ โ
โ โ - Enregistre les fonctions atexit โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ main (votre code) โ โโโ ENFIN ! โ
โ โ - printf("Hello, World!\n") โ โ
โ โ - return 0 โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ exit โ โ
โ โ - Appelle les fonctions atexit โ โ
โ โ - Ferme les flux (stdout, etc.) โ โ
โ โ - Appelle _exit (syscall) โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
main SโexรฉcuteFinalement, votre fonction main est appelรฉe. Elle exรฉcute printf("Hello, World!\n").
printf Fait Son Travailprintf est une fonction complexe qui :
%d, %s, etc.)Voici le chemin parcouru par notre texte :
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ VOYAGE DE "Hello, World!" JUSQU'ร L'รCRAN โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ printf("Hello, World!\n") โ
โ โ โ
โ โ (1) Formate la chaรฎne โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Buffer stdio (en mรฉmoire utilisateur)โ โ
โ โ "Hello, World!\n" โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โ (2) Le buffer est "flushรฉ" โ
โ โ (vidรฉ) car il y a un \n โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Appel systรจme write() โ โ
โ โ write(1, "Hello, World!\n", 14) โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โโโโโโโโโโโโโโโโชโโโโโโโโโโโโโโโโโโโโโโโ (frontiรจre โ
โ โ user/kernel) โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Noyau Linux โ โ
โ โ - Vรฉrifie le descripteur de fichier โ โ
โ โ - Copie les donnรฉes โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Pilote du terminal (tty) โ โ
โ โ - Interprรจte les caractรจres โ โ
โ โ - Gรจre le \n (nouvelle ligne) โ โ
โ โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ โ
โ โผ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ รmulateur de terminal / Console โ โ
โ โ โ โ
โ โ Hello, World! โ โ
โ โ โ โ โโโ Vous voyez โ
โ โ โ le texte ! โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Quand main retourne 0 :
0 est passรฉe ร exit()exit() effectue le nettoyage (ferme les fichiers, vide les buffers)_exit() est invoquรฉ0 est transmis au shellprintfprintf est bien plus quโune simple fonction dโaffichage. Cโest un vรฉritable interprรฉteur de format.
printfint printf(const char *format, ...);
const char *format : La chaรฎne de format... : Un nombre variable dโarguments (fonction variadique)Mรชme si notre Hello World nโen utilise pas, printf peut interprรฉter :
| Spรฉcificateur | Type attendu | Exemple |
|---|---|---|
%d ou %i |
int |
printf("%d", 42) โ 42 |
%u |
unsigned int |
printf("%u", 42) โ 42 |
%f |
double |
printf("%f", 3.14) โ 3.140000 |
%c |
char |
printf("%c", 'A') โ A |
%s |
char * |
printf("%s", "Hi") โ Hi |
%p |
void * |
printf("%p", ptr) โ 0x7fff... |
%x |
unsigned int (hex) |
printf("%x", 255) โ ff |
%% |
(aucun) | printf("%%") โ % |
printf Fait Vraimentโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ FONCTIONNEMENT INTERNE DE printf โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ printf("Valeur: %d, Nom: %s\n", 42, "Alice"); โ
โ โ
โ 1. Parse la chaรฎne de format : โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ "Valeur: " โ %d โ ", Nom: " โ %s โ "\n" โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ texte spec texte spec texte โ
โ โ
โ 2. Pour chaque รฉlรฉment : โ
โ - Texte โ copie directement dans le buffer โ
โ - Spรฉcificateur โ rรฉcupรจre l'argument correspondant โ
โ et le convertit en texte โ
โ โ
โ 3. Rรฉsultat dans le buffer : โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ V โ a โ l โ e โ u โ r โ : โ โ 4 โ 2 โ... โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ "Valeur: 42, Nom: Alice\n" โ
โ โ
โ 4. รcrit le buffer vers stdout โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
puts et non printf ?Si vous examinez le code assembleur gรฉnรฉrรฉ, vous verrez souvent puts au lieu de printf. Cโest une optimisation de GCC :
printf("Hello\n") โ Pas de formatage nรฉcessaireputs("Hello") qui est plus simple et plus rapideputs ajoute automatiquement un \n, donc GCC retire le \n de la chaรฎne.
Notre chaรฎne "Hello, World!\n" est stockรฉe dโune faรงon particuliรจre en mรฉmoire.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ "Hello, World!\n" EN MรMOIRE โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ Adresse Contenu Caractรจre Code ASCII โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ 0x1000 0x48 'H' 72 โ
โ 0x1001 0x65 'e' 101 โ
โ 0x1002 0x6C 'l' 108 โ
โ 0x1003 0x6C 'l' 108 โ
โ 0x1004 0x6F 'o' 111 โ
โ 0x1005 0x2C ',' 44 โ
โ 0x1006 0x20 ' ' 32 โ
โ 0x1007 0x57 'W' 87 โ
โ 0x1008 0x6F 'o' 111 โ
โ 0x1009 0x72 'r' 114 โ
โ 0x100A 0x6C 'l' 108 โ
โ 0x100B 0x64 'd' 100 โ
โ 0x100C 0x21 '!' 33 โ
โ 0x100D 0x0A '\n' 10 (newline) โ
โ 0x100E 0x00 '\0' 0 (terminateur) โ
โ โฒ โ
โ โ โ
โ Caractรจre nul : โ
โ marque la fin de โ
โ la chaรฎne โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Points importants :
\0 (caractรจre nul), ajoutรฉ automatiquement.rodata (lecture seule)Notre minuscule programme de 7 lignes produit un exรฉcutable dโenviron 16 Ko. Pourquoi ?
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ STRUCTURE DE L'EXรCUTABLE hello โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ En-tรชte ELF โ 64 octets โ
โ โ - Magic number: 7f 45 4c 46 โ (identifie ELF) โ
โ โ - Architecture: x86-64 โ โ
โ โ - Point d'entrรฉe: _start โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Program Headers โ โ
โ โ - Segments ร charger en mรฉmoire โ โ
โ โ - Permissions (lecture/exรฉcution) โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ .text (code) โ ~200 octets โ
โ โ - main โ โ
โ โ - Code d'initialisation โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ .rodata (donnรฉes RO) โ ~50 octets โ
โ โ - "Hello, World!" โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ .dynamic โ โ
โ โ - Liste des bibliothรจques requises โ โ
โ โ - libc.so.6 โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ .symtab / .strtab โ โ
โ โ - Table des symboles โ โ
โ โ - Noms des fonctions โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ Section Headers โ โ
โ โ - Mรฉtadonnรฉes sur les sections โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
# Taille du fichier
ls -l hello
# -rwxr-xr-x 1 user user 16696 ... hello
# Informations sur le format
file hello
# hello: ELF 64-bit LSB pie executable, x86-64, ...
# Voir les sections
size hello
# text data bss dec hex filename
# 1418 600 8 2026 7ea hello
# Voir les bibliothรจques liรฉes
ldd hello
# linux-vdso.so.1 (0x00007fff...)
# libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f...)
# /lib64/ld-linux-x86-64.so.2 (0x00007f...)
Mรชme notre simple Hello World fait appel au noyau Linux via des appels systรจme (syscalls).
Lโoutil strace permet de voir tous les appels systรจme :
strace ./hello
Sortie simplifiรฉe :
execve("./hello", ["./hello"], ...) = 0
brk(NULL) = 0x55a...
mmap(...) = 0x7f3... # Allocation mรฉmoire
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", ...) = 3
read(3, "\177ELF..."..., 832) = 832 # Lecture de la libc
close(3) = 0
...
write(1, "Hello, World!\n", 14) = 14 # โ Notre printf !
exit_group(0) = ? # โ Notre return 0
| Syscall | Rรดle dans notre programme |
|---|---|
execve |
Lance notre programme |
mmap |
Alloue de la mรฉmoire |
openat |
Ouvre la libc |
read |
Lit le contenu de la libc |
write |
รcrit ยซ Hello, World!\n ยป sur stdout |
exit_group |
Termine le programme |
Notre petit printf se traduit par un appel systรจme write(1, "Hello, World!\n", 14) :
1 = descripteur de fichier pour stdout14 = nombre dโoctets ร รฉcrireVoici le voyage complet de notre Hello World :
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ LE VOYAGE COMPLET DU HELLO WORLD โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ โ
โ 1. รCRITURE โ
โ Vous รฉcrivez hello.c (7 lignes) โ
โ โ โ
โ โผ โ
โ 2. PRรPROCESSEUR โ
โ #include โ 800 lignes โ
โ โ โ
โ โผ โ
โ 3. COMPILATION โ
โ C โ Assembleur (~30 lignes) โ
โ โ โ
โ โผ โ
โ 4. ASSEMBLAGE โ
โ Assembleur โ Code machine โ
โ โ โ
โ โผ โ
โ 5. รDITION DE LIENS โ
โ + libc โ Exรฉcutable (~16 Ko) โ
โ โ โ
โ โผ โ
โ 6. EXรCUTION โ
โ ./hello โ
โ โ โ
โ โโโ Chargement en mรฉmoire โ
โ โโโ Rรฉsolution des symboles โ
โ โโโ _start โ __libc_start_main โ main โ
โ โ โ
โ โผ โ
โ 7. printf("Hello, World!\n") โ
โ โ โ
โ โโโ Formatage de la chaรฎne โ
โ โโโ รcriture dans le buffer โ
โ โโโ Flush du buffer (grรขce au \n) โ
โ โ โ
โ โผ โ
โ 8. write(1, "Hello, World!\n", 14) โ
โ โ โ
โ โโโ Appel systรจme vers le noyau โ
โ โโโ Pilote TTY โ
โ โ โ
โ โผ โ
โ 9. AFFICHAGE โ
โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ $ ./hello โ โ
โ โ Hello, World! โ โ
โ โ $ โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ
โ 10. TERMINAISON โ
โ return 0 โ exit(0) โ code de retour au shell โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Ce simple programme de 7 lignes met en ลuvre :
Le Hello World nโest pas quโun rite de passage pour les programmeurs dรฉbutants. Cโest une fenรชtre sur lโensemble de la pile logicielle, du code source jusquโau matรฉriel.
Maintenant, quand vous verrez Hello, World! sโafficher ร lโรฉcran, vous saurez tout ce qui se cache derriรจre ces quelques caractรจres !