Fonction C

void ft_putnbr(int n);

Affiche l'entier n sur la sortie standard.

void ft_putstr(char const *s);

Affiche la chaîne s sur la sortie standard

void ft_putendl(char const *s);

Affiche la chaîne s sur la sortie standard suivi d'un '\n'

void ft_putchar(char c);

Affiche le caractère c sur la sortie standard.

int strncmp (const char *s1, const char *s2, size_t n);

idem sauf qu'elle ne compare que les n (au plus) premiers caractères de s1.

idem sauf qu'elle ne compare que les n (au plus) premiers caractères de s1.

idem ue strcpy + sauf que seuls les n premiers octets de src sont copiés.S'il n'y a pas d'octet nul dans les n premiers octets de src, la chaîne résultante ne disposera pas d'octet nul final.

void *memccpy (void *dest, const void *src, int c, size_t n);

copie au plus n octets de la zone mémoire src vers la zone mémoire dest, s'arrêtant dès qu'elle rencontre le caractère c.

char *strcpy (char *dest, const char *src);

copie la chaîne pointée par src (y compris le caractère « \0 » final) dans la chaîne pointée par dest. Les deux chaînes ne doivent pas se chevaucher. La chaîne dest doit être assez grande pour accueillir la copie.

void *memmove (void *dest, const void *src, size_t n);

copie n octets de la zone de mémoire src vers la zone dest. Les deux zones peuvent se chevaucher : la copie se passe comme si les octets de src étaient d'abord copiés dans une zone temporaire qui ne chevauche ni src ni dst, et les octets sont ensuite copiés de la zone temporaire vers dest.

void *memcpy (void *dest, const void *src, size_t n);

copie n octets depuis la zone mémoire src vers la zone mémoire dest. Les deux zones ne doivent pas se chevaucher.

char * strdup (const char *s);

envoie un pointeur sur une nouvelle chaîne de caractères qui est dupliquée depuis s. La mémoire occupée par cette nouvelle chaîne est obtenue en appelant malloc(3), et peut (doit) donc être libérée avec free(3).

void *memchr (const void *s, int c, size_t n);

examine les n premiers octets de la zone mémoire pointée par s à la recherche du caractère c. Le premier octet correspondant à c (interprété comme un unsigned char) arrête l'opération.

char * ft_strsub(char const *s, unsigned int start, size_t len);

Alloue (avec malloc(3)) et retourne la copie "fraiche" d'un tronçon de la chaîne de caractères passée en paramètre. Le tronçon commence à l'index start et a pour longueur len. Si start et len ne désignent pas un tronçon de chaîne valide, le comportement est indéterminé. Si l'allocation échoue, la fonction renvoie NULL

char ** ft_strsplit(char const *s, char c);

Alloue (avec malloc(3)) et retourne un tableau de chaînes de caractères "fraiches" (toutes terminées par un '\0', le tableau également donc) résultant de la découpe de s selon le caractère c. Si l'allocation echoue, la fonction retourne NULL

char * ft_strnew(size_t size);

Alloue (avec malloc(3)) et retourne une chaîne de caractère "fraiche" terminée par un '\0'. Chaque caractère de la chaîne est initialisé à '\0'. Si l'allocation echoue, la fonction renvoie NULL.

char* ft_itoa(int n);

Alloue (avec malloc(3)) et retourne une chaîne de caractères "fraiche" terminée par un '\0' représentant l'entier n passé en paramètre. Les nombres négatifs doivent être gérés. Si l'allocation échoue, la fonction renvoie NULL.

char * ft_strjoin(char const *s1, char const *s2);

Alloue (avec malloc(3)) et retourne une chaîne de caractères "fraiche" terminée par un '\0' résultant de la concaténation de s1 et s2. Si l'allocation echoue, la fonction renvoie NULL.

char * ft_strtrim(char const *s);

Alloue (avec malloc(3)) et retourne une copie de la chaîne passée en paramètre sans les espaces blancs au debut et à la fin de cette chaîne. On considère comme espaces blancs les caractères ' ', '\n' et '\t'. Si s ne contient pas d'espaces blancs au début ou à la fin, la fonction renvoie une copie de s. Si l'allocation echoue, la fonction renvoie NULL

void * ft_memalloc(size_t size);

Alloue (avec malloc(3)) et retourne une zone de mémoire "fraiche". La mémoire allouée est initialisée à 0. Si l'allocation échoue, la fonction renvoie NULL.

size_t strlcat(char * dest, const char * src, size_t count);

Append a length-limited, NUL-terminated string to another

void ft_striteri(char *s, void (*f)(unsigned int, char *));

Applique la fonction f à chaque caractère de la chaîne de caractères passée en paramètre en précisant son index en premier argument. Chaque caractère est passé par adresse à la fonction f afin de pouvoir être modifié si nécessaire.

char * ft_strmapi(char const *s, char (*f)(unsigned int, char));

Applique la fonction f à chaque caractère de la chaîne de caractères passée en paramètre en précisant son index pour créer une nouvelle chaîne "fraiche" (avec malloc(3)) résultant des applications successives de f.

char * ft_strmap(char const *s, char (*f)(char));

Applique la fonction f à chaque caractère de la chaîne de caractères passée en paramètre pour créer une nouvelle chaîne "fraiche" (avec malloc(3)) résultant des applications successives de f.

void ft_striter(char *s, void (*f)(char *));

Applique la fonction f à chaque caractère de la chaîne de caractères passée en paramètre. Chaque caractère est passé par adresse à la fonction f afin de pouvoir être modifié si nécessaire

void ft_strclr(char *s);

Assigne la valeur '\0' à tous les caractères de la chaîne passée en paramètre.

int ft_strnequ(char const *s1, char const *s2, size_t n);

Compare lexicographiquement s1 et s2 jusqu'à n caractères maximum ou bien qu'un '\0' ait été rencontré. Si les deux chaînes sont égales, la fonction retourne 1, ou 0 sinon.

int ft_strequ(char const *s1, char const *s2);

Compare lexicographiquement s1 et s2. Si les deux chaînes sont égales, la fonction retourne 1, ou 0 sinon.

void ft_putnbr_fd(int n, int fd);

Ecrit l'entier n sur le descripteur de fichier fd.

void ft_putendl_fd(char const *s, int fd);

Ecrit la chaîne s sur le descripteur de fichier fd suivi d'un '\n'.

void ft_putstr_fd(char const *s, int fd);

Ecrit la chaîne s sur le descripteur de fichier fd.

void ft_putchar_fd(char c, int fd);

Ecrit le caractère c sur le descripteur de fichier fd.

Alloue (avec malloc(3)) et retourne une chaîne de caractère "fraiche" terminée par un '\0'. Chaque caractère de la chaîne est initialisé à '\0'. Si l'allocation echoue, la fonction renvoie NULL.

Find the first substring in a length-limited string

void ft_strdel(char **as);

Prend en paramètre l'adresse d'une chaîne de caractères qui doit être libérée avec free(3) et son pointeur mis à NULL

char *ft_strcat (char *dest, const char *src);

ajoute la chaîne src à la fin de la chaîne dest en écrasant le caractère nul (« \0 ») à la fin de dest, puis en ajoutant un nouveau caractère nul final. Les chaînes ne doivent pas se chevaucher, et la chaîne dest doit être assez grande pour accueillir le résultat.

size_t strlen (const char *s);

calcule la longueur de la chaîne de caractères s, sans compter le carèctere nul « \0 » final.

char *strstr (const char *meule_de_foin, const char *aiguille);

cherche la première occurrence de la sous-chaîne aiguille au sein de la chaîne meule_de_foin. Les caractères « \0 » de fin ne sont pas comparés.

int ft_strcmp (const char *s1, const char *s2);

compare les deux chaînes s1 et s2. Elle renvoie un entier négatif, nul, ou positif, si s1est respectivement inférieure, égale ou supérieure à s2.

int memcmp (const void *s1, const void *s2, size_t n);

compare les n premiers octets des zones mémoire s1 et s2. Elle renvoie un entier inférieur, égal, ou supérieur à zéro, si s1 est respectivement inférieure, égale ou supérieur à s2.

int toupper (int c);

convertit la lettre c en majuscule si c'est possible.

int atoi (const char *nptr);

convertit le début de la chaîne pointée par nptr en entier de type int.

int ft_atoi(char *str)

int ft_atoi(char *str) { int i; int res; int sign; i = 0; res = 0; sign = 1; while ((str[i] > 8 && str[i] < 14) || (str[i] == 32)) i++; if ((str[i] == '-') || (str[i] == '+')) { sign = (str[i] == '-') ? -1 : 1; i++; } while (str[i] >= '0' && str[i] <= '9') { res = res * 10 + str[i] - '0'; i++; } res = sign * res; return (res); }

char *strncat (char *dest, const char *src, size_t n);

la chaîne résultante dans dest est toujours terminée par un caractère nul. Si srccontient n caractères ou plus, strcat() écrit n+1 caractères dans dest (n de src plus le caractère nul final). Aussi, la taille de dest doit être au moins strlen(dest)+n+1.

void bzero (void *s, size_t n);

met à 0 (octets contenant « \0 ») les n premiers octets du bloc pointé par s.

void *memset (void *s, int c, size_t n);

remplit les n premiers octets de la zone mémoire pointée par s avec l'octet c.

char *strrchr (const char *s, int c);

renvoie un pointeur sur la dernière occurrence du caractère c dans la chaîne s.

char *ft_strchr (const char *s, int c);

renvoie un pointeur sur la première occurrence du caractère c dans la chaîne s.

int tolower (int c);

tolower() convertit la lettre c en minuscule si c'est possible.

void ft_memdel(void **ap);

void ft_memdel(void **ap);

void ft_putnbr(int nb)

void ft_putnbr(int nb) { if (nb / 10) ft_putnbr(nb / 10); else if (nb < 0) ft_putchar('-'); ft_putchar(nb % 10 * (nb < 0 ? -1 : 1) + '0'); }

int isprint (int c);

vérifie s'il s'agit d'un caractère imprimable, y compris l'espace.

int isascii (int c);

vérifie si c est un unsigned char sur 7 bits, entrant dans le jeu de caractères ASCII.

int isalpha (int c);

vérifie si l'on a un caractère alphabétique. Dans la localisation "C" standard, c'est équivalent à (isupper(c) || islower(c)). Dans certaines localisations, il peut y avoir des caractères supplémentaires pour lesquels isalpha() est vrai, c'est-à-dire pour des lettres qui ne sont ni majuscules ni minuscules.

int isalnum (int c);

vérifie si l'on a un caractère alphanumérique. C'est équivalent à (isalpha(c) || isdigit(c)).

int isdigit (int c);

vérifie si l'on a un chiffre (0 à 9).