Vue d'ensemble
But : découper une chaîne en mots séparés par un caractère
Entrée : `char const *s`, séparateur `char c`. Sortie : `char **` (tableau de chaînes allouées, terminé par NULL). L'appelant doit libérer la mémoire.
1) count_word
static int count_word(char const *s, char c)
Ce que ça fait : compte combien de mots non vides sont présents dans s, séparés par c.
Entrées : s (chaîne), c (séparateur)
Retour : entier = nombre de mots (0 si aucun)
Comportement : ignore séparateurs consécutifs ; ne compte pas de mot vide en début/fin.
Complexité : O(n) temps, O(1) mémoire
Exemples :
count_word("hello world", ' ') → 2
count_word(" a b ", ' ') → 2
count_word("", ' ') → 0
2) create_new_word
static char *create_new_word(char const *s, int word, size_t i)
Ce que ça fait : alloue et copie la sous-chaîne s[word..i-1] dans une nouvelle chaîne C terminée par '\0'.
Entrées : s (source), word (index début), i (index fin exclus).
Retour : pointeur vers la chaîne allouée ou NULL si malloc échoue.
Note : alloue i - word + 1 octets pour inclure le '\0' et copie caractère par caractère.
Ex : s="hello world", word=0, i=5 → "hello"
3) free_split
static void *free_split(char **split, int j)
Ce que ça fait : libère split[0] à split[j-1] puis libère le tableau split lui-même. Retourne NULL pour permettre return (free_split(...));.
Usage typique : nettoyer en cas d'échec d'allocation pendant la construction du tableau.
4) init_value
static void init_value(size_t *i, int *k, int *word)
Ce que ça fait : initialise *i = 0, *k = 0, *word = -1. Simple helper pour clarifier la lecture dans ft_split.
5) ft_split (fonction principale)
char **ft_split(char const *s, char c)
But : diviser s en tableau de mots séparés par c. Chaque mot est alloué séparément ; tableau terminé par NULL.
Étapes clés :
- Vérifier
s != NULL.
- Compter le nombre de mots :
nb = count_word(s,c).
- Allouer le tableau `split` avec `nb + 1` pointeurs (dernier = NULL).
- Parcourir la chaîne avec un marqueur `word = -1` pour début non trouvé ; mettre `word = i` quand `s[i] != c` et `word < 0`.
- Quand on atteint `c` ou `\0` et `word >= 0`, appeler `create_new_word(s, word, i)` et stocker dans `split[k++]`.
- Si une allocation échoue, appeler `free_split` pour nettoyer et retourner `NULL`.
Cas limites : s == NULL → retourne NULL. "" → retourne tableau contenant simplement NULL. Séparateurs consécutifs n'ajoutent pas de mots vides.
/* Exemples d'appel (conceptuels) */
ft_split("hello world", ' ') -> ["hello", "world", NULL]
ft_split(" a b ", ' ') -> ["a", "b", NULL]
ft_split("", ' ') -> [NULL]
ft_split(NULL, ' ') -> NULL