Cette annexe donne la syntaxe des principales fonctions de la librairie
standard. Une liste exhaustive de
toutes les fonctions disponibles figure à
l'annexe B de l'ouvrage de Kernighan et Richie. Pour obtenir plus d'informations
sur ces fonctions, il suffit de consulter les pages de
man
correspondant.
A.1 Entrées-sorties <stdio.h>
A.1.1 Manipulation de fichiers
L'usage des fonctions de manipulation de
fichiers suivantes est détaillé au chapitre 6.
| fonction |
action |
| fopen |
ouverture d'un fichier |
| fclose |
fermeture d'un fichier |
| fflush |
écriture des buffers en mémoire dans le
fichier |
A.1.2 Entrées et sorties formatées
La syntaxe de ces fonctions et leur
action sont décrites aux paragraphes 1.11 et 6.2-6.3.
| fonction |
prototype |
action |
| fprintf |
int fprintf(FILE *stream, char *format, ...) |
écriture sur un fichier |
| fscanf |
int fscanf(FILE *stream, char *format, ...) |
lecture depuis un fichier |
| printf |
int printf(char *format, ...) |
écriture sur la sortie standard |
| scanf |
int scanf(char *format, ...) |
lecture depuis l'entrée standard |
| sprintf |
int sprintf(char *s, char *format, ...) |
écriture dans la chaîne de
caractères s |
| sscanf |
int sscanf(char *s, char *format, ...) |
lecture depuis la chaîne de
caractères s |
A.1.3 Impression et lecture de caractères
| fonction |
prototype |
action |
| fgetc |
int fgetc(FILE *stream) |
lecture d'un caractère depuis un fichier |
| fputc |
int fputc(int c, FILE *stream) |
écriture d'un caractère sur un fichier |
| getc |
int getc(FILE *stream) |
équivalent de fgetc mais implémenté par une
macro |
| putc |
int putc(int c, FILE *stream) |
équivalent de fputc mais implémenté par une
macro |
| getchar |
int getchar(void) |
lecture d'un caractère depuis l'entrée
standard |
| putchar |
int putchar(int c) |
écriture d'un caractère sur la sortie
standard |
| fgets |
char *fgets(char *s, FILE *stream) |
lecture d'une chaîne de caractères depuis un
fichier |
| fputs |
int *fputs(char *s, FILE *stream) |
écriture d'une chaîne de caractères sur un
fichier |
| gets |
char *gets(char *s) |
lecture d'une chaîne de caractères sur l'entrée
standard |
| puts |
int *puts(char *s) |
écriture d'une chaîne de caractères sur la sortie
standard |
A.2 Manipulation de caractères
<ctype.h>
Toutes les fonctions ci-dessous
permettent de tester une propriété du caractère passé en paramètre. Elles
renvoient la valeur 1 si le caractère vérifie la propriété et 0 sinon. Leur
prototype est :
int fonction(char c)
| fonction |
renvoie 1 si le caractère est |
| isalnum |
une lettre ou un chiffre |
| isalpha |
une lettre |
| iscntrl |
un caractère de commande |
| isdigit |
un chiffre décimal |
| isgraph |
un caractère imprimable ou le blanc |
| islower |
une lettre minuscule |
| isprint |
un caractère imprimable (pas le blanc) |
| ispunct |
un caractère imprimable qui n'est ni une lettre ni un
chiffre |
| isspace |
un blanc |
| isupper |
une lettre majuscule |
| isxdigit |
un chiffre
hexadécimal |
On dispose également de
deux fonctions permettant la conversion entre lettres minuscules et lettres
majuscules :
| fonction |
prototype |
action |
| tolower |
int tolower(int c) |
convertit c en minuscule si c'est une lettre
majuscule, retourne c sinon. |
| toupper |
int toupper(int c) |
convertit c en majuscule si c'est une lettre
minuscule, retourne c
sinon. |
A.3 Manipulation de chaînes de caractères
<string.h>
| fonction |
prototype |
action |
| strcpy |
char *strcpy(char *ch1, char *ch2) |
copie la chaîne ch2 dans la chaîne
ch1 ; retourne ch1. |
| strncpy |
char *strcpy(char *ch1, char *ch2, int n) |
copie n caractères de la chaîne ch2
dans la chaîne ch1 ; retourne ch1. |
| strcat |
char *strcat(char *ch1, char *ch2) |
copie la chaîne ch2 à la fin de la chaîne
ch1 ; retourne ch1. |
| strncat |
char *strncat(char *ch1, char *ch2, int n) |
copie n caractères de la chaîne ch2
à la fin de la chaîne ch1 ; retourne ch1. |
| strcmp |
int strcmp(char *ch1, char *ch2) |
compare ch1 et ch2 pour l'ordre
lexicographique ; retourne une valeur négative si ch1 est inférieure à
ch2, une valeur positive si ch1 est supérieure à ch2,
0 si elles sont identiques. |
| strncmp |
int strcmp(char *ch1, char *ch2, int n) |
compare les n premiers caractères de
ch1 et ch2. |
| strchr |
char *strchr(char *chaine, char c) |
retourne un pointeur sur la première occurence de
c dans chaine, et NULL si c n'y figure
pas. |
| strrchr |
char *strchr(char *chaine, char c) |
retourne un pointeur sur la dernière occurence de
c dans chaine, et NULL si c n'y figure
pas. |
| strstr |
char *strchr(char *ch1, char *ch2) |
retourne un pointeur sur la première occurence de
ch2 dans ch1, et NULL si ch2 n'y figure
pas. |
| strlen |
int strlen(char *chaine) |
retourne la longueur de chaine.
|
A.4 Fonctions mathématiques
<math.h>
Le résultat et les paramètres de
toutes ces fonctions sont de type
double. Si les paramètres effectifs
sont de type
float, ils seront convertis en
double par le
compilateur.
| fonction |
action |
| acos |
arc cosinus |
| asin |
arc sinus |
| atan |
arc tangente |
| cos |
cosinus |
| sin |
sinus |
| tan |
tangente |
| cosh |
cosinus hyperbolique |
| sinh |
cosinus hyperbolique |
| tanh |
tangente hyperbolique |
| exp |
exponentielle |
| log |
logarithme népérien |
| log10 |
logarithme en base 10 |
| pow |
puissance |
| sqrt |
racine carrée |
| fabs |
valeur absolue |
| fmod |
reste de la division |
| ceil |
partie entière supérieure |
| floor |
partie entière inférieure
|
A.5 Utilitaires divers <stdlib.h>
A.5.1 Allocation dynamique
Ces fonctions sont décrites au chapitre 3,
paragraphe 3.4.
| fonction |
action |
| calloc |
allocation dynamique et initialisation à zéro. |
| malloc |
allocation dynamique |
| realloc |
modifie la taille d'une zone préalablement allouée par
calloc ou malloc. |
| free |
libère une zone mémoire |
A.5.2 Conversion de chaînes de caractères en nombres
Les fonctions
suivantes permettent de convertir une chaîne de caractères en un
nombre.
| fonction |
prototype |
action |
| atof |
double atof(char *chaine) |
convertit chaine en un
double |
| atoi |
int atoi(char *chaine) |
convertit chaine en un int |
| atol |
long atol(char *chaine) |
convertit chaine en un long int
|
A.5.3 Génération de nombres pseudo-aléatoires
La fonction
rand
fournit un nombre entier pseudo-aléatoire dans l'intervalle
[0,
RAND_MAX], où
RAND_MAX est une constante prédéfinie au
moins égale à 2
15-1. L'aléa fournit par la
fonction
rand n'est toutefois pas de très bonne qualité.
La
valeur retournée par
rand dépend de l'initialisation (germe) du
générateur. Cette dernière est égale à 1 par défaut mais elle peut être modifiée
à l'aide de la fonction
srand.
| fonction |
prototype |
action |
| rand |
int rand(void) |
fournit un nombre entier pseudo-aléatoire |
| srand |
void srand(unsigned int germe) |
modifie la valeur de l'initialisation du générateur
pseudo-aléatoire utilisé par rand. |
A.5.4 Arithmétique sur les entiers
| fonction |
prototype |
action |
| abs |
int abs(int n) |
valeur absolue d'un entier |
| labs |
long labs(long n) |
valeur absolue d'un long int |
| div |
div_t div(int a, int b) |
quotient et reste de la division euclidienne de
a par b. Les résultats sont stockés dans les champs
quot et rem (de type int) d'une structure de type
div_t. |
| ldiv |
ldiv_t ldiv(long a, long b) |
quotient et reste de la division euclidienne de
a par b. Les résultats sont stockés dans les champs
quot et rem (de type long int) d'une structure de
type ldiv_t. |
A.5.5 Recherche et tri
Les fonctions
qsort et
bsearch
permettent respectivement de trier un tableau, et de rechercher un élément dans
un tableau déjà trié. Leur syntaxe est détaillée au chapitre 4.
A.5.6 Communication avec l'environnement
| fonction |
prototype |
action |
| abort |
void abort(void) |
terminaison anormale du programme |
| exit |
void exit(int etat) |
terminaison du programme ; rend le contrôle au système
en lui fournissant la valeur etat (la valeur 0 est considérée comme une
fin normale). |
| system |
int system(char *s) |
exécution de la commande système définie par la chaîne
de caractères s. |
A.6 Date et heure <time.h>
Plusieurs
fonctions permettent d'obtenir la date et l'heure. Le temps est représenté par
des objets de type
time_t ou
clock_t, lesquels correspondent
généralement à des
int ou à des
long int.
| fonction |
prototype |
action |
| time |
time_t time(time_t *tp) |
retourne le nombre de secondes écoulées depuis le
1er janvier 1970, 0 heures G.M.T. La
valeur retournée est assignée à *tp. |
| difftime |
double difftime(time_t t1, time_t t2) |
retourne la différence t1 - t2 en
secondes. |
| ctime |
char *ctime(time_t *tp) |
convertit le temps système *tp en une chaîne
de caractères explicitant la date et l'heure sous un format
prédéterminé. |
| clock |
clock_t clock(void) |
retourne le temps CPU en microsecondes utilisé depuis
le dernier appel à clock. |
0 comments:
Post a Comment