← Retour aux projets

ft_printf

GitHub

ft_printf est ma réimplémentation de printf en C, livrée sous forme de librairie (libftprintf.a). Le projet vise à reproduire un comportement proche de la libc tout en travaillant des fondamentaux souvent cachés derrière une simple fonction d’affichage.

L’objectif est double :

  • Comprendre le fonctionnement des variadic arguments (stdarg) et du typage dynamique induit par le format.
  • Construire un moteur de parsing + formatting fiable, capable de gérer des combinaisons de règles (flags, largeur, précision) sans effet de bord.

Principe

ft_printf(format, ...) :

  1. Parcourt la chaîne format.
  2. Écrit les caractères “normaux” tels quels.
  3. À chaque %, analyse une mini-grammaire :
  • flags (-, 0)
  • largeur minimale (nombre ou *)
  • précision (. + nombre ou *)
  • conversion (c, s, p, d, i, u, x, X, %)
    4. Récupère l’argument correspondant via va_list, applique le formatting, puis écrit le résultat.

La fonction retourne le nombre total de caractères écrits, comme printf.

Points importants

  • Gestion des priorités :

  • - (alignement gauche) écrase l’effet du padding 0.

  • la précision (.) peut modifier le comportement du padding (notamment pour les nombres).
  • Largeur et précision via * : lecture dynamique depuis les arguments.
  • Conversion hexadécimale en minuscule/majuscule (x / X) et gestion du pointeur (p).
  • Pas de buffer interne : le rendu est produit au fil de l’eau.

Contraintes respectées

  • Fonctions autorisées : malloc, free, write, va_start, va_arg, va_copy, va_end
  • Compilation en librairie avec ar → libftprintf.a (pas libtool)
  • Comportement comparé au printf de la libc
  • Interdiction d’implémenter un buffer type libc

Ce que ça m’a apporté

Ce projet m’a appris à construire un code modulaire et extensible : séparation claire entre parsing, représentation du format (struct), dispatch par conversion, et printers dédiés.

C’est aussi un excellent exercice de rigueur sur les edge cases et les interactions entre règles : largeur vs précision, padding 0 vs -, conversions numériques vs string, etc. — avec en plus la contrainte de maintenir un compteur exact de caractères écrits.

Bonus

  • Gestion de conversions supplémentaires (ex. f…)
  • Gestion de flags/modifiers additionnels (ex. #, +, espace, l/ll/h/hh, etc.)

Objectif :

un code modulaire et facilement extensible (notamment pour les bonus)

1. Parser

  • détecte %
  • lit flags (-0)
  • lit largeur (nombre ou *)
  • lit précision (. puis nombre ou *)
  • lit conversion (cspdiuxX%)

2. Modèle de format

  • struct t_fmt (flags, width, precision, type, etc.)

3. Dispatcher / Printers

  • une fonction par conversion (ex: print_int, print_hex, print_ptr…)
  • applique padding/alignement/précision avant d’écrire

4. Output layer

  • wrappers write() + compteur global des chars écrits

Bonus:

  • conversions : n f g e
  • flags/modifiers : l ll h hh et # + (et espace)