termine le processus en cours, imprime le message : "abort core
dumped".
retourne la valeur absolue de n (n entier).
retourne la valeur de arc cosinus(x) dans l'intervalle [0,pi], x doit
être compris entre -1 et +1.
char *asctime
( temps )
struct tm *temps;
construit depuis une structure de type "tm", une chaîne de 26 caractères donnant la date et l'heure (ex: Tue Apr 2 13:03:52 1985\n\0). Retourne un pointeur sur cette chaîne. Cette chaîne est située en zone statique, la même zone étant utilisée à chaque appel de "asctime" et de "ctime".
Le type struct tm est défini, dans "time.h" de la façon suivante:
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
L'heure varie entre 0 et 23, le jour entre 1 et 31, le mois entre 0
et 11, le jour de la semaine entre 0 (dimanche) et 6, le jour de l'année
entre 0 et 365. L'année représente l'année courante moins 1900. "isdt"
est un indicateur qui est non nul, si la conversion due à l'heure d'été
doit être appliquée.
retourne la valeur de arc sinus(x) dans l'intervalle [-pi/2,pi/2], x
doit être compris entre -1 et +1.
void assert
( test )
int test;
lors de l'exécution, si le test est faux, un message apparait indiquant
le nom du fichier et la ligne où cela se produit, puis le programme se
termine.
retourne la valeur de arc tangente(x) dans l'intervalle [-pi/2,pi/2].
double atan2
( x , y )
double x , y;
retourne la valeur de arc tangente(y/x) dans l'intervalle [-pi,pi].
double atof
( chaine )
char *chaine;
convertit une chaîne de caractères en réel de type double.
int atoi (
chaine )
char *chaine;
convertit une chaîne de caractères en entier.
long atol
( chaine )
char *chaine;
convertit une chaîne de caractères en entier de type long.
char *bsearch
( cle , base , nel , taille , compare )
char *cle , *base;
unsigned nel , taille;
int ( *compare ) ( );
recherche dichotomique dans une table. Les éléments de cette table doivent
être triés par ordre croissant avant l'appel de bsearch. "cle"
est un pointeur sur l'élément cherché, "base" l'adresse du tableau,
"nel" le nombre d'éléments de ce tableau, "taille"
la taille en octets d'un élément. "compare" est une fonction
qui compare deux éléments, retournant 0 en cas d'égalité et un entier positif
(respectivement négatif) si le premier élément est supérieur (respectivement
inférieur) au second. Retourne l'adresse du premier élément de la table
correspondant à la clé de recherche, NULL si aucun élément ne correspond.
char *calloc
( n , taille )
unsigned n , taille;
alloue un tableau de n éléments de longueur taille (aligné pour tout
type), le tableau est initialisé à 0. En cas d'espace mémoire insuffisant,
retourne NULL.
retourne le plus petit entier supérieur ou égal à x.
int chdir
( path )
char *path;
pour se positionner dans le répertoire dont "path" est le
chemin d'accès. Retourne 0 en cas de succès, -1 sinon.
void clearerr
( fichier )
FILE *fichier;
remet à zéro les indicateurs d'erreurs et de fin de fichier relatifs
au fichier indiqué.
retourne le temps CPU écoulé en microsecondes depuis le premier appel
à "clock". La résolution de l'horloge est de 20 millisecondes.
retourne le cosinus de x. Si x est trop grand une erreur de type PLOSS
(perte partielle de précision) ou de type TLOSS (perte totale de précision)
est générée. Seule la seconde conduit à l'émission d'un message sur stderr.
retourne le cosinus hyperbolique de x.
char *ctime
( clock )
long *clock;
construit depuis un entier pointé par clock, (repésentant le temps écoulé
en secondes depuis le 1er janvier 1970 à 0 heure), une chaîne de 26 caractères
donnant la date et l'heure (voir "asctime").
Retourne un pointeur sur cette chaîne.
char *ecvt
( reel , nb_chiffre , pospoint , signe )
double reel;
int nb_chiffre , *pospoint , *signe;
convertit le réel, en une chaîne de caractères, (avec "nb_chiffre").
*pospoint contient la position du point décimal par rapport au début de
la chaîne. *signe contient 0 si le nombre est positif, autre chose sinon.
Retourne un pointeur sur cette chaîne. Attention, cette chaîne est dans
la zone statique, et chaque appel de cette fonction réutilise la même zone,
et donc écrase les données précédentes.
void exit
( status )
int status;
termine le processus en cours, vide les buffers, ferme tous les fichiers,
status est le code retour.
retourne exponentiel de x.
retourne la valeur absolue de x (x est un décimal).
int fclose
( fichier )
FILE *fichier;
ferme un fichier, retourne EOF en cas d'erreur, 0 sinon.
char *fcvt
( reel , nb_chiffre , pospoint , signe )
double reel int nb_chiffre , *pospoint , *signe;
identique à ecvt, mais avec arrondi du
résultat selon le format F du Fortran.
int feof (
fichier )
FILE *fichier;
retourne une valeur non nulle quand une fin de fichier a été détectée
par une tentative de lecture, 0 si ce n'est pas le cas.
int ferror
( fichier )
FILE *fichier;
retourne une valeur non nulle si une erreur de lecture ou d'écriture
s'est produite sur le fichier, zéro sinon. Attention seuls la fermeture
du fichier ou l'appel à clearerr ou
à rewind remet l'indicateur à 0.
int fflush
( fichier )
FILE *fichier;
vide le buffer lié au fichier, retourne 0 si tout s'est bien passé,
EOF sinon.
int fgetc
( fichier )
FILE *fichier;
lit un caractère dans un fichier, rend ce caractère.
char fgets
( tampon , n , fichier)
char *tampon;
int n;
FILE *fichier;
lit des caractères dans "fichier" jusqu'à n-1 caractères ou
bien jusqu'à un caractère \n, ou bien jusqu'à la fin du fichier. Les caractères
lus sont rangés dans la chaîne qui est terminée par un \0. Retourne l'adresse
de "tampon", NULL en cas d'erreur.
retourne le plus grand entier inférieur ou égal à x.
double fmod
( x , y )
double x , y;
retourne le reste réel r de x/y, tel que x=iy+r, ou i est un entier,
r a le même signe que x, et r est en valeur absolue inférieur à y. Si y=0,
il y a overflow et la fonction retourne 0.
FILE *fopen
( nomfichier , type )
char *nomfichier , *type;
ouvre un fichier de nom "nomfichier", type spécifie le type d'accès :
r : lecture, fichier devant exister
w : écriture, si le fichier est non vide il est vidé
a : écriture en fin de fichier, crée le fichier si besoin est
r+ : lecture et écriture, fichier devant exister
w+ : lecture et écriture, si le fichier existe il est vidé
a+ : lecture et ajout en fin de fichier, crée le fichier si besoin
est
r+t : lecture fichier texte
w+t : écriture fichier texte
a+t : ajout fichier texte
r+b : lecture fichier binaire
w+b : écriture fichier binaire
a+b : ajout fichier binaire
retourne un pointeur sur le descripteur de fichier, NULL en cas d'erreur.
int fprintf
( fichier , format , arg1 , arg2 , ... )
FILE *fichier char *format;
écriture formatée dans un fichier (voir printf).
int fputc
( c , fichier )
int c;
FILE *fichier;
écrit le caractère c dans un fichier, retourne le caractère écrit.
int fputs
( chaine , fichier)
char *chaine;
FILE *fichier;
écrit la "chaine" dans le fichier. Retourne EOF en cas d'erreur.
int fread
( tampon , p , n , fichier )
char *tampon int n , p;
FILE *fichier;
lit n objets de taille p dans un fichier et les range dans le tampon,
retourne le nombre d'objets réellement lus.
void free
( adresse )
char *adresse;
libère le bloc de mémoire pointé par adresse, et précédement alloué
par malloc, calloc,
ou realloc.
FILE *freopen
( nom , type , fichier )
char *nom , *type;
FILE *fichier;
ferme le fichier associé à "fichier", et lui réassigne le
fichier nom, avec le mode type. Les types et le code retour sont analogues
à ceux de fopen.
double frexp
( valeur , eptr )
double valeur;
int *eptr;
tout nombre non nul peut s'écrire de manière unique sous la forme d'un
produit d'une mantisse x et d'un exposant n de 2, tel que 0.5 <= |x|
< 1.0 et n est un entier. Retourne la mantisse x, et range l'exposant
n à l'adresse eptr.
int fscanf
( fichier , format , arg1 , arg2 , ... )
FILE *fichier;
char *format;
lecture formatée dans un fichier (voir scanf).
int fseek
( fichier , offset , origine )
FILE *fichier;
long offset;
int origine;
déplacement de offset octets dans un fichier depuis la position origine définie par:
0 : SEEK_SET : début du fichier
1 : SEEK_CUR : position courante
2 : SEEK_END : fin de fichier
retourne 0 si tout s'est bien passé, autre chose sinon.
long ftell
( fichier )
FILE *fichier;
retourne la position relative du pointeur courant du fichier par rapport au début du fichier. Une valeur de -1L indique une erreur.
int fwrite
( tampon , p , n , fichier )
char *tampon;
int n , p;
FILE *fichier;
écrit n objets de taille p dans un fichier à partir de tampon, retourne
le nombre d'objets réellement écris.
char *gcvt
( reel , nb_chiffre , tampon )
double reel;
int nb_chiffre;
char *tampon;
convertit le réel, en une chaîne de caractères, (avec "nb_chiffre").
Retourne un pointeur sur cette chaîne. Cette chaîne est placée dans "tampon".
Si cela est possible il utilise le format F, sinon il utilise le format
E.
int getc (
fichier )
FILE *fichier;
analogue à fgetc, mais définie par une
macro.
équivalent à getc (stdin), analogue à
fgetchar, mais définie par une macro.
char *getenv
( nom )
char *nom;
recherche dans l'environnement une chaîne de la forme "nom=valeur"
et retourne en cas de succès un pointeur sur la chaîne
"valeur", retourne NULL en cas d'échec.
char *gets
( tampon )
char *tampon;
lit une ligne (suite de caractères jusqu'à \n) sur stdin, et la range
dans "tampon" (en remplaçant \n par \0), retourne l'adresse du
tampon, NULL en cas d'erreur, ou bien de fin de fichier sans avoir rien
lu.
int getw (
fichier )
FILE *fichier;
lit un entier depuis fichier. Retourne la valeur lue, EOF en cas de
fin de fichier, mais attention EOF peut aussi être une valeur lue (consulter
feof ou ferror).
struct tm
*gmtime ( clock )
long *clock;
retourne un pointeur vers une structure de type tm
contenant les éléments constitutifs de la date et de l'heure. Cette date
est calculée en temps GMT à partir de clock,
(représentant le temps écoulé en secondes depuis le 1er janvier 1970 à
0 heure). Cette structure est située en zone statique, la même zone étant
utilisée à chaque appel de "gmtime" et de "localtime".
(Voir "asctime" pour la définition
de la structure tm).
déclenche l'interruption logicielle "sig".
retourne une valeur non nulle si c est un caractère alphanumérique,
0 sinon.
retourne une valeur non nulle si c est une lettre, 0 sinon.
retourne une valeur non nulle si c est un caractère ascii
(de code inférieur à 128), 0 sinon.
retourne une valeur non nulle si c est un caractère de contrôle ou "DEL"
(c'est à dire de code compris entre 0 et 31, ou 127), 0 sinon.
retourne une valeur non nulle si c est un chiffre décimal, 0 sinon.
retourne une valeur non nulle si c est un caractère imprimable à l'exception
de l'espace (code compris entre 33 et 126), 0 sinon.
retourne une valeur non nulle si c est une lettre minuscule, 0 sinon.
retourne une valeur non nulle si c est un caractère imprimable (code
compris entre 32 et 126), 0 sinon.
retourne une valeur non nulle si c est un caractère de ponctuation,
0 sinon.
retourne une valeur non nulle si c est "espace", ou \n, \t,
\r, \v, \f, 0 sinon.
retourne une valeur non nulle si c est une lettre majuscule, 0 sinon.
retourne une valeur non nulle si c est un chiffre héxadécimal, 0 sinon.
double ldexp
( valeur, exp )
double valeur;
int exp;
retourne valeur multiplié par 2^exp. En cas de débordement retourne + ou - HUGE et errno recoit ERANGE.
struct
tm *localtime ( clock )
long *clock;
identique à "gmtime" mais effectue les corrections dues au décalage horaire et éventuellement à l'heure d'été.
retourne le logarithme néperien de x.
retourne le logarithme décimal de x.
longjmp
( environnement , valeur )
jmp_buf environnement;
capture l'environnement dans la variable "environnement" de type jmp_buf (défini dans set_jmp). Retourne 0 lors de l'appel initial. Un appel ultérieur à la fonction longjmp, avec la variable environnement correspond à la remise dans l'état qui a été capturé, et avec la valeur retournée transmise en paramètre longjmp.
char *malloc
( taille )
unsigned taille;
alloue un bloc de mémoire de taille octets (aligné pour tout type), retourne un pointeur sur ce bloc. En cas de place mémoire insuffisante, retourne NULL.
int matherr
( x )
struct exception *x;
Lorsqu'il se produit une erreur lors de l'exécution d'une fonction mathématique, la fonction matherr est appellée. Cette fonction reçoit comme paramètre une structure de type exception :
struct exception {
int type;
char *name;
double arg1 , arg2;
double retval;
};
ou type spécifie (constantes définies dans math.h) le type de l'erreur commise dans la fonction:
DOMAIN : argument(s) hors du domaine de la fonction
SING : un argument a une valeur illégale
OVERFLOW :
UNDERFLOW :
TLOSS : perte totale de signification
PLOSS : perte partielle de signification
où name est le nom de la fonction, arg1 et arg2 sont les valeurs des arguments, et retval est la valeur retournée par la fonction pour cette erreur. Si matherr retourne 0, un message d'erreur est affiché et errno contient le numéro de l'erreur; si elle retourne autre chose, pas de message d'erreur et errno inchangé. L'utilisateur peut écrire sa propre fonction matherr (ce sera donc la sienne qui sera utilisée), ce qui lui permet de gérer les erreurs des fonctions mathématiques.
char *memccpy
( dest , srce , c , n )
char *dest , *srce;
int c , n;
copie de zéro à n caractères de srce vers dest jusqu'à la première occurence de c (y compris c) ou jusqu'à n octets (suivant le cas qui se produit le premier). Si "c" est recopié, retourne un pointeur vers le caractère suivant c dans dest, sinon retourne NULL.
char *memchr
( mem , c , n )
char *mem;
int c , n;
recherche la première occurence de c dans le bloc de taille n pointé par mem. Retourne l'adresse de cette première occurence dans mem, NULL s'il n'a pas trouvé c.
int memcmp
( adr1 , adr2 , n )
char *adr1 , *adr2;
int n;
compare les n premiers octets des deux emplacements mémoire. Retourne un résultat analogue à celui des strcmp.
char *memcpy
( dest , srce , n )
char *dest, *srce;
int n;
copie n octets de la zone srce vers la zone dest. Retourne un pointeur vers dest.
char *memset
( dest , c , n )
char *dest;
int c , n;
remplit n octets de la zone dest avec le caractère c. Retourne un pointeur vers dest.
int mkdir
( path , mode )
char *path;
int mode;
crée un nouveau répertoire de nom path, le mode est initialisé à "mode". Retourne 0 en cas de succès, -1 sinon.
double modf
( x , y )
double x , y;
retourne la partie fractionnaire signée de "valeur" et range la partie entière à l'adresse "iptr".
void perror
( chaine )
char *chaine;
imprime le message "chaîne" fourni par l'utilisateur, puis le message système correspondant à la valeur de errno, qui a été mis à jour lors de la dernière erreur.
double pow
( x , y )
double x , y;
retourne la valeur de x à la puissance y.
int printf
(format , arg1 , arg2 , ...)
char *format;
impression formattée sur la sortie standard (stdout). Chaque argument est évalué lors de la rencontre dans le format d'un :
%[flag][largeur][.précision][l]type où:
flag vaut :
+ : la sortie est signée en cas de nombre
- : sortie justifiée à gauche
^' : préfixe d'un blanc les nombres positifs (^ symbolise ici le blanc
qu'il faut laisser devant l'apostrophe)
largeur indique le nombre minimum de caractères à imprimer
précision indique :
pour une chaîne, le nombre maximum de caractères à imprimer
pour un entier, le nombre minimum de chiffre à imprimer
pour un flottant, le nombre de chiffres après la virgule
type:
d : entier
hd : entier de type short
ld : entier de type long
x : entier en hexadécimal
X : entier en hexadécimal
u : unsigned
f : float en notation virgule fixe
e : float en notation virgule flottante
g : float en virgule "mixte"
c : caractère
s : chaîne
l pour les "long"
Retourne le nombre de caractères imprimés.
int putc (
c , fichier )
FILE *fichier;
analogue à fputc, mais définie par une macro.
équivalent à putc ( c , stdout ), analogue à fputchar, mais définie par une macro.
int puts (
chaine )
char *chaine;
écrit la chaîne sur la sortie standard stdout, remplace le \0 par \n. Retourne EOF en cas d'erreur.
int putw (
entier , fichier )
int entier;
FILE *fichier;
écrit un entier dans un fichier, sans alignement. Retourne la valeur écrite, EOF si erreur, mais EOF peut aussi être une valeur écrite (consulter ferror ).
void qsort
( base , nel , taille , compare )
char *base;
unsigned nel , taille;
int ( *compare )( );
trie un tableau par un algorithme de quicksort. "base" est l'adresse du tableau, "nel" le nombre d'éléments de ce tableau, "taille" la taille en octets d'un élément. "compare" est une fonction qui compare deux éléments, retournant 0 en cas d'égalité et un entier positif (respectivement négatif) si le premier élément est supérieur (respectivement inférieur) au second.
retourne un nombre entier pseudo-aléatoire compris entre 0 et 32767.
char *realloc
( adresse , taille )
char *adresse;
unsigned taille;
change la taille du bloc mémoire pointé par adresse et alloué précédement par malloc ou calloc, taille est la nouvelle taille souhaitée. Cette fonction retourne un pointeur sur le nouveau bloc, NULL si espace mémore insuffisant.
int rename
( ancien , nouveau )
char *ancien , *nouveau;
renomme un fichier. Retourne 0 en cas de succès, -1 sinon.
int rewind
( fichier )
FILE *fichier;
repositionne le pointeur du fichier en début de ce fichier, et repositionne à 0 l'indicateur d'erreur de ce fichier. Retourne une valeur non nulle en cas d'erreur, 0 sinon.
int remdir
( path )
char *path;
supprime le répertoire de chemin "path", le répertoire doit être vide. Retourne 0 en cas de succès, -1 sinon.
int scanf
( format , arg1 , arg2 , ...)
char *format;
lecture formattée sur le fichier d'entrée standard stdin. Chaque argument doit être un pointeur sur un variable de type correspondant à un des spécificateurs du format. Les "format" sont analogues à ceux de printf (sans la précision), (par exemple %d pour lire un entier, %ld pour lire un long, %hd pour un short). Retourne le nombre de champs lus.
void setbuf
( fichier , buffer )
FILE *fichier;
char *buffer;
change la zone tampon utilisée par "fichier" pour ses opérations d'entrées-sorties. Il force le système à utiliser la zone d'adresse "buffer". Cette fonction doit être utilisée après l'ouverture du fichier mais avant toute opération sur ce fichier. Si "buffer" est la valeur NULL, les entrées-sorties sur ce fichier ne seront pas bufferisées. La zone tampon fournie doit être de taille "BUFSIZ" (constante définie dans "stdio.h").
int setjmp
( environnement )
jmp_buf environnement;
capture l'environnement dans la variable "environnement" de type jmp_buf (défini dans setjmp.h). Retourne 0 lors de l'appel initial. Un appel ultérieur à la fonction longjmp, avec la variable environnement correspond à la remise dans l'état qui a été capturé, et avec la valeur retournée transmise en paramètre de longjmp.
void setbuf
( fichier , buffer )
FILE *fichier;
char *buffer;
change la zone tampon utilisée par "fichier" pour ses opérations d'entrées-sorties. Il force le système à utiliser la zone d'adresse "buffer". Cette fonction doit être utilisée après l'ouverture du fichier mais avant tout opération sur ce fichier. Si "buffer" est la valeur NULL, les entrées-sorties sur ce fichier ne seront pas bufferisées. La zone tampon fournie doit être de taille "BUFSIZ" (constante définie dans "stdio.h").
int ( *signal
( sig , fonction ) ) ( )
int sig;
int ( *fonction ) ( );
permet de modifier l'action effectuée lors d'une interruption. Lorsque l'interruption sig (voir la liste ci-dessous) est reçue, la fonction spécifiée sera effectuée.
si "fonction" vaut SIG_DFL alors l'action standard (par défaut) sera effectuée (c'est-à-dire un exit (2)), si "fonction" vaut SIG_IGN le signal est ignoré (sauf SIGKILL). Si "fonction" est une fonction fournie par l'utilisateur, celle-ci sera exécutée lors de la réception du signal.
Liste des interruptions :
SIGUP : hangup
SIGINT : interruption
SIGQUIT : quit
SIGILL : instruction illégale
SIGTRAP : piège du pas à pas
SIGABRT : processus interrompu
SIGBOUNDS : bornes dépassées
SIGFPE : erreur sur le bus
SIGSEGV : viol de segmentation
SIGSYS : appel système invalide
SIGALRM : alarme horloge
SIGTERM : signal de terminaison logicielle
SIGUSR1 : signal numéro 1 défini par l'utilisateur
SIGUSR2 : signal numéro 2 défini par l'utilisateur
SIGCLD : mort d'un processus fils
SIGPWR : erreur d'alimentation
SIGINTOVER : "overflow" entier
SIGINTDIVZERO : division entière par 0
SIGREALOVER : "overflow" flottant
SIGREALUNDER : "underflow" flottant
SIGREALDIVZERO : division flottante par 0
SIGREALINEX : erreur en calcul flottant
SIGREALINV : opération flottante
retourne la valeur de sinus hyperbolique de x.
retourne la valeur de sinus hyperbolique de x.
unsigned
sleep ( temps )
unsigned temps;
suspend l'exécution pendant "temps" secondes.
int sprintf
( buffer , format , arg1 , arg2 , ... )
char *buffer;
char *format;
analogue à printf, mais écriture dans le buffer.
retourne la racine carrée de x.
void srand
( init )
unsigned init;
initialise le générateur de nombres pseudo-aléatoires.
int sscanf
( buffer , format , arg1 , arg2 , ... )
char *buffer;
char *format;
analogue à scanf, mais lecture dans le buffer.
int ( *ssignal
( sig , fonction ) ) ( )
int sig;
int ( *fonction ) ( );
fonctionne comme "signal", mais en réception des interruptions "software" provoquées par l'utilisateur grâce à la fonction "gsignal".
char *strcat
( chaine1 , chaine2 )
char *chaine1 , *chaine2;
concatène chaîne2 à chaîne1, rend un pointeur sur chaine1.
char *strchr
( chaine , c )
char *chaine;
int c;
retourne un pointeur sur la première occurence de c dans la chaîne, NULL si c n'apparaît pas.
int strcmp
( chaine1 , chaine2 )
char *chaine1 , *chaine2;
compare les deux chaînes, retourne 0 en cas d'égalité, une valeur négative si chaîne1 est "avant" chaîne2, une valeur positive sinon.
char *strcpy
( dest , srce )
char *dest , *srce;
copie la chaîne "srce" dans la chaîne "dest", rend un pointeur sur dest.
int strcspn
( chaine , ens )
char *chaine , *ens;
retourne l'indice du premier caractère de la chaîne qui appartient à ens. C'est donc la longueur de la sous chaîne initiale ne contenant aucun caractère de ens.
int strlen
( chaine )
char *chaine;
rend la longueur de la chaîne, sans compter l'\0.
char *strncat
( chaine1 , chaine2 , n )
char *chaine1 , *chaine2;
int n;
concatène au plus les n premiers caractères de chaine2 à chaine1. Retourne un pointeur sur chaine1. Si n est plus grand que la longueur de chaine2, la longueur de chaine2 est utilisée à la place de n.
int strncmp
( chaine1 , chaine2 , n)
char *chaine1 , *chaine2;
int n;
compare de façon analogue à strcmp les au plus n premiers caractères des deux chaînes.
char *strncpy
( chaine1 , chaine2 , n)
char *chaine1 , *chaine2;
int n;
copy n caractères de chaine2 sur chaine1. Retourne un pointeur sur chaine1. Si n est inférieur à longueur de chaine2 \0 n'est pas ajouté en fin de chaine1. Si n est inférieur à longueur de chaine2, chaine1 est complétée par des \0.
char *strpbrk
( chaine1 , chaine2 )
char *chaine1 , *chaine2;
retourne un pointeur sur la première occurence dans chaine1 d'un caractère de chaine2. Retourne NULL si aucun caractère en commun.
char *strrchr
( chaine , c )
char *chaine;
int c;
retourne un pointeur sur la dernière occurence de c dans la chaîne, NULL si c n'apparaît pas.
int strspn
( chaine1 , chaine2 )
char *chaine1 , chaine2;
retourne l'index du premier caractère de chaine1 qui n'appartient pas à chaine2. Il s'agit donc de la longueur de la sous chaîne initiale de chaine1 qui est composée d'éléments de chaine2.
double strtod
( chaine , pointeur )
char *chaine , **pointeur;
retourne (sous forme de double) la valeur représentée par "chaine". La chaîne est examinée jusqu'au premier caractère qui ne peut être interprété dans le nombre. L'adresse de ce caractère est mise dans la zone d'adresse "pointeur" (sauf si "pointeur" est NULL). Retourne 0 si aucun nombre n'a pu être formé.
char *strtok
( chaine1 , chaine2 )
char *chaine1 , *chaine2;
lecture de chaine1 comme une suite de "mots" séparés par les éléments de chaine2. Les différents mots sont obtenus par une série d'appels successifs, le premier avec chaine1, les suivants avec NULL comme premier paramètre. Retourne un pointeur sur le mot trouvé (terminé par \0), NULL si on arrive en fin de chaîne. Le pointeur chaine1 n'est pas modifié, mais dans la chaîne initiale chaque séparateur suivant un mot est remplacé par \0.
long strtol
( chaine , pointeur , base )
char *chaine , **pointeur;
int base;
analogue à "strtod" mais rend un long. "base" (de 1 à 36) indique la base dans laquelle le nombre lu doit être interprété. Si "base" est égal à 0, le début de la chaîne indique la base (0x pour l'hexadécimal, 0.. pour l'octal, décimal sinon).
int system
( chaine )
char *chaine;
exécute la commande contenue dans chaine. Retourne 0 en cas d'exécution correcte, une valeur négative sinon.
retourne la valeur de tangente (x).
retourne la tangente hyperbolique de x.
long time
( adresse )
long *adresse;
retourne le temps écoulé en secondes depuis le 1 janvier 1970 à 0h 0mn 0s. Ce temps est aussi rangé à l'adresse "adresse", sauf si celle ci vaut NULL.
crée un fichier temporaire (à l'aide de "tmpnam") et retourne un pointeur sur "FILE". Le fichier est ouvert avec l'option "w+", et est détruit à la fin du processus. Cette fonction retourne NULL si le fichier n'a pu être ouvert.
crée un nom de fichier nouveau qui peut être utilisé comme nom de fichier temporaire en toute sécurité. Retourne l'adresse de la chaîne contenant ce nom. Cette chaîne est mise soit dans une zone fournie par l'utilisateur (paramètre "s") soit dans une zone statique si "s" est NULL.
si c est une majuscule retourne c converti en minuscule, sinon retourne c.
si c est une minuscule retourne c converti en majuscule, sinon retourne c.
int ungetc
( c , fichier )
int c;
FILE *fichier;
insère le caractère "c" dans le buffer de "fichier". Ce caractère sera le prochain à être lu. Retourne "c" et ne modifie pas le fichier.