Section courante

A propos

Section administrative du site

Vue par prototype   Rechercher

Voici un tableau de référence des différents fonctions du C pour Unix (aussi connu sous le nom de built-in functions) :

Nom Prototype Description Entête fichier
A64L long a64l(const char *s) Cette fonction permet de convertir une chaine de caractères ASCII radix-64 en entier 32 bits. stdlib.h
ABORT void abort(void) Cette procédure permet d'interrompre l'exécution du programme de façon anormale. stdlib.h
ABS int abs(int a) Cette fonction retourne la valeur absolue. stdlib.h
ACCEPT int accept (int socket, struct sockaddr *address, socklen_t *address_len) Cette fonction permet d'accepter une nouvelle connexion sur un socket. sys/socket.h
ACCESS int access(const char *path, int amode) Cette fonction permet de vérifier le mode d'accès d'un fichier. unistd.h
ACOS double acos(double a) Cette fonction trigonométrique retourne l'«ArcCosinus». math.h
ACOSH double acosh(double a) Cette fonction trigonométrique retourne la valeur de l'«ArcCosinus» hyperbolique. math.h
ADD_WCH int add_wch(const cchar_t *wch) Cette fonction permet d'ajouter un caractère à une fenêtre. curses.h
ADD_WCHNSTR int add_wchnstr(const cchar_t *wchstr, int n) Cette fonction permet d'ajouter une chaine de caractères d'une longueur spécifié à une fenêtre. curses.h
ADD_WCHSTR int add_wchstr(const cchar_t *wchstr) Cette fonction permet d'ajouter une chaine de caractères à une fenêtre. curses.h
ADVANCE int advance(const char *string, const char *expbuf) Cette fonction permet de retourner une expression régulière compilé à part d'une palette de masque. regexp.h
AIO_CANCEL int aio_cancel(int fildes, struct aiocb *aiocbp) Cette fonction permet d'annuler la synchronisation d'une requête d'entrée/sortie en temps réel. aio.h
AIO_ERROR int aio_error(const struct aiocb *aiocbp) Cette fonction permet de retourner l'erreur d'un bloc de contrôle de synchronisation d'entrée/sortie en temps réel. aio.h
AIO_FSYNC int aio_fsync(int op, struct aiocb *aiocbp) Cette fonction permet d'effectuer la synchronisation d'un fichier dans la synchronisation d'entrée/sortie en temps réel. aio.h
AIO_READ int aio_read(struct aiocb *aiocbp) Cette fonction permet d'effectuer la lecture dans un fichier dans la synchronisation d'entrée/sortie en temps réel. aio.h
AIO_RETURN ssize_t aio_return(struct aiocb *aiocbp) Cette fonction permet retourne l'état actuel d'une opération dans la synchronisation d'entrée/sortie en temps réel. aio.h
AIO_SUSPEND int aio_suspend(const struct aiocb * const list[], int nent, const struct timespec *timeout) Cette fonction permet d'attendre après une requête d'une opération dans la synchronisation d'entrée/sortie en temps réel. aio.h
AIO_WRITE int aio_write(struct aiocb *aiocbp) Cette fonction permet d'effectuer l'écriture dans un fichier dans la synchronisation d'entrée/sortie en temps réel. aio.h
ALARM unsigned int alarm(unsigned int seconds) Cette fonction permet de fixer une ordonnance pour l'émission d'un signal à un processus après l'intervalle de temps spécifié. unistd.h
ASCTIME char *asctime(struct tm *h) Cette fonction permet de convertir de l'heure en chaine de caractères. time.h
ASCTIME_R char *asctime_r(const struct tm *tm, char *buf); Cette fonction permet de convertir de l'heure en chaîne de caractères en utilisant un tampon d'au moins 26 octets pour entreposer la réponse. time.h
ASIN double asin(double a) Cette fonction trigonométrique retourne l'«ArcSinus». math.h
ASINH double asinh(double a) Cette fonction trigonométrique retourne la valeur de l'«ArcSinus» hyperbolique. math.h
ASSERT void assert(int exp) Cette fonction permet de vérifier le programme. assert.h
ATAN double atan(double a) Cette fonction trigonométrique retourne l'«ArcTangente». math.h
ATAN2 double atan2(double y,double x) Cette fonction trigonométrique retourne l'«ArcTangente» de Y/X. math.h
ATANH double atanh(double a) Cette fonction trigonométrique retourne la valeur de l'«ArcTangente» hyperbolique. math.h
ATEXIT int atexit(void (*ptrfonction)(void)) Cette fonction doit être appelé à la fin d'un programme pour le terminer. stdlib.h
ATOF double atof(const char *str) Cette fonction convertie une chaîne de caractères en une valeur «float». stdlib.h
ATOI int atoi(const char *str) Cette fonction convertie une chaîne de caractères en une valeur entière «int». stdlib.h
ATOL long atol(const char *str) Cette fonction convertie une chaîne de caractères en une valeur entière «long». stdlib.h
ATTROFF int attroff(int attrs) Cette fonction permet de désactiver les attributs d'une fenêtre. curses.h
ATTRON int attron(int attrs) Cette fonction permet d'activer les attributs d'une fenêtre. curses.h
ATTRSET int attrset(int attrs) Cette fonction permet de fixer l'attribut d'arrière-plan d'une fenêtre. curses.h
ATTR_GET int attr_get(attr_t *attrs, short *color_pair_number, void *opts) Cette fonction permet de demander l'attribut d'une fenêtre. curses.h
ATTR_OFF int attr_off(attr_t attrs, void *opts) Cette fonction permet de désactiver les attributs d'une fenêtre. curses.h
ATTR_ON int attr_on(attr_t attrs, void *opts) Cette fonction permet d'activer les attributs d'une fenêtre. curses.h
ATTR_SET int attr_set(attr_t attrs, short color_pair_number, void *opts) Cette fonction permet de fixer l'attribut d'une fenêtre. curses.h
BASENAME char *basename(char *path) Cette fonction permet de retourner la dernière partie d'une chemin de fichier. libgen.h
BAUDRATE int baudrate(void) Cette fonction permet de retourner le taux de transmission en baud. curses.h
BCMP int bcmp(const void *s1, const void *s2, size_t n) Cette fonction permet d'effectuer la comparaison du début de deux blocs de données en octets. strings.h
BCOPY void bcopy(const void *s1, void *s2, size_t n) Cette fonction permet d'effectuer la copie du début d'un blocs de données en octets dans un autre bloc de données. strings.h
BEEP int beep(void) Cette fonction permet d'émettre un signal sonore de style «Bip». curses.h
BIND int bind(int socket, const struct sockaddr *address, socklen_t address_len) Cette fonction permet de fixer le nom d'un socket. sys/socket.h
BRK int brk(void *addr); Cette fonction permet de fixer l'extrémité supérieure du segment de données du processus appelant sur l'adresse spécifié. unistd.h
BSD_SIGNAL void (*bsd_signal(int sig, void (*func)(int)))(int); Cette fonction permet de fournir une interface partiellement compatible pour les programmes écrits sur des interfaces de systèmes d'historiques. signal.h
BSEARCH void *bsearch(const void *key,const void *base, size_t num, size_t width, int(*compare)(const void *elem1,const void void *elem2)) Cette fonction effectue une recherche binaire (dichotomique) dans un tableau. stdlib.h
BTOWC wint_t btowc(int c); Cette fonction permet de convertir un simple octet en caractère Unicode. wchar.h
BZERO void bzero(void *s, size_t n); Cette fonction permet de fixer la valeur à chaque octet d'un bloc de données d'octets à la valeur 0. strings.h
CALLOC void *calloc(size_t n,size_t taille) Cette fonction permet d'effectuer une réservation de n*taille d'octets de mémoire dynamique. stdlib.h
CATCLOSE int catclose(nl_catd catd); Cette fonction permet de fermer un catalogue de messages. nl_types.h
CATGETS char *catgets(nl_catd catd, int set_id, int msg_id, const char *s); Cette fonction permet de recevoir le contenu d'un message de catalogue. nl_types.h
CATOPEN nl_catd catopen(const char *name, int oflag); Cette fonction permet d'ouvrir un catalogue de messages. nl_types.h
CBRT double cbrt(double x); Cette fonction retourne la racine cubique du nombre spécifié. math.h
CFGETISPEED speed_t cfgetispeed(const struct termios *termios_p); Cette fonction permet de retourner la vitesse de la ligne d'entrée entreposé dans la structure *termios-p. termios.h
CFGETOSPEED speed_t cfgetospeed(const struct termios *termios_p); Cette fonction permet de retourner la vitesse de la ligne de sortie entreposé dans la structure *termios-p. termios.h
CFSETISPEED int cfsetispeed(struct termios *termios_p, speed_t speed); Cette fonction permet d'entreposer la vitesse dans la structure *termios-p comme vitesse d'entrée. termios.h
CFSETOSPEED int cfsetospeed(struct termios *termios_p, speed_t speed); Cette fonction permet d'entreposer la vitesse dans la structure *termios-p comme vitesse de sortie. termios.h
CHDIR int chdir(const char *dirname) Cette fonction permet de changer le répertoire courant avec une chaîne de caractères ASCIZ. unistd.h
CHMOD int chmod(const char *path, mode_t mode); Cette fonction permet de changer les droits d'accès des répertoires et des fichiers. sys/stat.h
CHOWN int chown(const char *path, uid_t owner, gid_t group); Cette fonction permet de changer les propriétaires et les groupes de propriétaire (GID) des fichiers. unistd.h
CHROOT int chroot(const char *path); Cette fonction permet de changer le répertoire racine. unistd.h
CEIL double ceil(double a) Cette fonction retourne la valeur maximale d'un nombre, soit l'entier le plus proche supérieur ou égal au nombre. math.h
CLEARERR void clearerr(FILE *ptrfic) Cette procédure élimine les indices d'erreurs et de fin de fichier. stdio.h
CLOCK clock_t clock(void) Cette fonction indique le temps que l'ordinateur a utilisé depuis le début de son exécution. time.h
CLOCK_GETRES int clock_getres(clockid_t clock_id, struct timespec *res); Cette fonction permet de demander la résolution de n'importe quel horloge. time.h
CLOCK_GETTIME int clock_gettime(clockid_t clock_id, struct timespec *tp); Cette fonction permet de demander la valeur courante spécifié pour l'horloge spécifié. time.h
CLOCK_SETTIME int clock_settime(clockid_t clock_id, const struct timespec *tp); Cette fonction permet de fixer l'horloge spécifié avec la valeur spécifié. time.h
CLOSE int close(int fildes); Cette fonction permet d'effectuer la fermeture du descripteur de fichiers. unistd.h
CLOSEDIR int closedir(DIR *dirp); Cette fonction permet de fermer un répertoire ouvert préalablement par «opendir». dirent.h
CLOSELOG void closelog(void); Cette fonction permet de fermer la connexion au journal de bord. syslog.h
COMPILE char *compile(char *instring, char *expbuf, const char *endbuf, int eof); Cette fonction permet de produire une expression régulière compilé. regexp.h
CONFSTR size_t confstr(int name, char *buf, size_t len); Cette fonction permet d'effectuer la lecture d'une chaîne de caractères contenu dans une configuration. unistd.h
COS double cos(double a) Cette fonction trigonométrique retourne le «Cosinus». math.h
COSH double cosh(double a) Cette fonction trigonométrique retourne le «Cosinus» hyperbolique. math.h
CREAT int creat(const char *path, mode_t mode); Cette fonction permet de créer un nouveau fichier. fcntl.h
CTERMID char *ctermid(char *s); Cette fonction permet de demander l'identificateur du terminal de contrôle. stdio.h
CTIME char *ctime(const time_h *h) Cette fonction permet de convertir une heure sous forme de chaîne de caractères. time.h
CTIME_R char *ctime_r(const time_t *clock, char *buf); Cette fonction permet de convertir une heure sous forme de chaîne de caractères et place le résultat dans le tampon spécifié. time.h
CUSERID char *cuserid(char *s); Cette fonction permet de demander le nom de l'utilisateur actuellement connecté. stdio.h
DIFFTIME double difftime(time_h *h2,time *h1) Cette fonction permet de calculer la différence entre deux dates en secondes. time.h
DIRNAME char *dirname(char *path); Cette fonction permet de retourner le chemin de répertoire d'un nom de fichier complet ou relatif. libgen.h
DBM_CLEARERR int dbm_clearerr(DBM *db); Cette fonction permet d'effacer les conditions d'erreurs de la base de données. ndbm.h
DBM_CLOSE void dbm_close(DBM *db); Cette fonction permet de fermer la base de données. ndbm.h
DBM_DELETE int dbm_delete(DBM *db, datum key); Cette fonction permet d'effacer un enregistrement ainsi que sa clef de la base de données. ndbm.h
DBM_ERROR int dbm_error(DBM *db); Cette fonction permet de demander la condition d'erreur de la base de données. ndbm.h
DBM_FETCH datum dbm_fetch(DBM *db, datum key); Cette fonction permet de lire un enregistrement de la base de données. ndbm.h
DBM_FIRSTKEY datum dbm_firstkey(DBM *db); Cette fonction permet de retourner la premier clef dans la base de données. ndbm.h
DBM_NEXTKEY datum dbm_nextkey(DBM *db); Cette fonction permet de retourner la prochaine clef dans la base de données. ndbm.h
DBM_OPEN DBM *dbm_open(const char *file, int open_flags, mode_t file_mode); Cette fonction permet d'ouvrir une base de données. ndbm.h
DBM_STORE int dbm_store(DBM *db, datum key, datum content, int store_mode); Cette fonction permet d'écrire un enregistrement dans la base de données. ndbm.h
DIV div_t div(int a,int b) Cette fonction permet retourne le quotient et le reste séparément en effectuant la division a par b. stdlib.h
DLOPEN void *dlopen(const char *file, int mode); Cette fonction permet d'accéder à un fichier d'objet exécutable. dlfcn.h
DLSYM void *dlsym(void *handle, const char *name); Cette fonction permet de demander l'adresse d'un symbole dans l'objet dlopen(). dlfcn.h
DLCLOSE int dlclose(void *handle); Cette fonction permet de fermer l'objet dlopen(). dlfcn.h
DLERROR char *dlerror(void); Cette fonction permet de demander les informations de diagnostique. dlfcn.h
DRAND48 double drand48(void); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0,0 à 1,0. stdlib.h
DUP int dup(int fildes); Cette fonction permet de dupliquer le descripteur de fichier. unistd.h
DUP2 int dup2(int fildes, int fildes2); Cette fonction permet de dupliquer le descripteur de fichier dans un autre fichier de descripteur connu. unistd.h
ECVT char *ecvt(double value, int ndigit, int *decpt, int *sign); Cette fonction permet de convertir un nombre à virgule flottante en une chaîne de caractères. stdlib.h
ENCRYPT void encrypt(char block[64], int edflag); Cette fonction permet d'encrypter le bloc si le drapeau spécifié est à 0, sinon il décrypte le bloc en utilisant la clef précédemment définie par setkey. unistd.h
ENDGRENT void endgrent(void); Cette fonction permet de fermer le groupe de fichier. grp.h
ENDPWENT void endpwent(void); Cette fonction permet de fermer le flux de données interne utilisé par les fonctions getpwent ou getpwent_r. pwd.h
ENDUTXENT void endutxent(void); Cette fonction permet de fermer la base de données de compte utilisateur étendue. utmpx.h
ERAND48 double erand48(unsigned short int xsubi[3]); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0,0 à 1,0 en utilisant les données de génération de nombre spécifié. stdlib.h
ERF double erf(double x); Cette fonction retourne la valeur d'une erreur «normal». math.h
ERFC double erfc(double x); Cette fonction retourne la valeur complémentaire d'une erreur «normal». math.h
EXECL int execl(const char *path, const char *arg0, ... /*, (char *)0 */); Cette fonction permet d'exécuter un processus enfant avec une liste d'arguments. unistd.h
EXECLE int execle(const char *path, const char *arg0, ... /*, (char *)0, char *const envp[]*/); Cette fonction permet d'exécuter un processus enfant avec une liste d'arguments et ses variables d'environnement. unistd.h
EXECLP int execlp(const char *file, const char *arg0, ... /*, (char *)0 */); Cette fonction permet d'exécuter un processus enfant avec une liste d'arguments et en recherchant le programme dans la variable d'environnement «PATH». unistd.h
EXECV int execv(const char *path, char *const argv[]); Cette fonction permet d'exécuter un processus enfant avec un tableau d'arguments. unistd.h
EXECVE int execve(const char *path, char *const argv[], char *const envp[]); Cette fonction permet d'exécuter un processus enfant avec un tableau d'arguments et ses variables d'environnement. unistd.h
EXECVP int execvp(const char *file, char *const argv[]); Cette fonction permet d'exécuter un processus enfant avec un tableau d'arguments et en recherchant le programme dans la variable d'environnement «PATH». unistd.h
EXIT void exit(int etat) Cette procédure met fin à l'exécution d'un programme avec une valeur de retour. stdlib.h
EXP double exp(double x) Cette fonction calcul l'exponentiel de la valeur «x». math.h
EXPM1 double expm1(double x); Cette fonction retourne la valeur «exponentielle» sur la base «e» - 1. math.h
FABS double fabs(double a) Cette fonction calcul la valeur absolue d'un nombre réel. math.h
FATTACH int fattach(int fildes, const char *path); Cette fonction permet d'attacher un descripteur de fichier de flux de données à un fichier dans l'espace de noms du système de fichiers. stropts.h
FCHDIR int fchdir(int fildes); Cette fonction permet de changer le répertoire pour l'identificateur de descripteur de fichier. unistd.h
FCHMOD int fchmod(int fildes, mode_t mode); Cette fonction permet de changer le permission d'un fichier à partir de son identificateur de descripteur de fichier. sys/stat.h
FCHOWN int fchown(int fildes, uid_t owner, gid_t group); Cette fonction permet de changer le propriétaire d'un fichier à partir de son identificateur de descripteur de fichier. unistd.h
FCLOSE int fclose(FILE *ptrfichier) Cette fonction effectue la fermeture d'un fichier. stdio.h
FCVT char *fcvt(double value, int ndigit, int *decpt, int *sign); Cette fonction permet de convertir un nombre à virgule flottante en une chaîne de caractères. stdlib.h
FDATASYNC int fdatasync(int fildes); Cette fonction permet de s'assurer que toutes les données du fichier seront écrites sur le périphérique. unistd.h
FDETACH int fdetach(const char *path); Cette fonction permet de détacher un nom d'un descripteur de fichier dans le flux de données. stropts.h
FDOPEN FILE *fdopen(int fildes, const char *mode); Cette fonction permet d'associer un identificateur de fichier Handle à un identificateur de fichier standard. stdio.h
FD_CLR void FD_CLR(int fd, fd_set *fdset) Cette macro permet d'enlever un identificateur de descripteur de fichier de l'ensemble de descripteur de fichier. sys/time.h
FD_ISSET int FD_ISSET(int fd, fd_set *fdset) Cette macro permet de retourner une valeur différente de zéro (vrai) si le descripteur de fichier est un membre d'un ensemble de descripteur de fichier sinon il retournera 0 (faux). sys/time.h
FD_SET void FD_SET(int fd, fd_set *fdset) Cette macro permet d'ajouter un descripteur de fichier à l'ensemble de descripteur de fichier. sys/time.h
FD_ZERO void FD_ZERO(fd_set *fdset) Cette macro permet d'initialiser l'ensemble de descripteur de fichier en un ensemble vide. sys/time.h
FEOF int feof(FILE *ptrfichier) Cette fonction indique si la fin du fichier est atteint. stdio.h
FERROR int ferror(FILE *ptrfichier) Cette fonction retourne le code d'erreur d'entrée/sortie du fichier. stdio.h
FFLUSH int fflush(FILE *ptrfichier) Cette fonction vide le tampon du fichier. stdio.h
FFS int ffs(int i); Cette fonction permet de retourner la position du premier bit ayant la valeur 1. strings.h
FGETC int fgetc(FILE *ptrfichier) Cette fonction effectue la lecture d'un caractère dans un fichier. stdio.h
FGETPOS int fgetpos(FILE *ptrfichier,fpos_t *pos) Cette fonction demande la position du pointeur dans un fichier. stdio.h
FGETS char *fgets(char *str,int n,FILE *ptrfichier) Cette fonction effectue la lecture d'une chaîne de caractères dans un fichier. stdio.h
FGETWC wint_t fgetwc(FILE *stream); Cette fonction permet d'effectuer la lecture d'un caractère Unicode dans un fichier. wchar.h
FGETWS wchar_t *fgetws(wchar_t *ws, int n, FILE *stream); Cette fonction permet d'effectuer la lecture d'une chaîne de caractères Unicode dans un fichier. wchar.h
FILENO int fileno(FILE *stream); Cette fonction permet de demander l'identificateur Handle d'un fichier. stdio.h
FLOCKFILE void flockfile(FILE *file); Cette fonction permet d'effectuer un verrouillage d'accès à un fichier Handle. stdio.h
FLOOR double floor(double a) Cette fonction retourne la valeur minimale d'un nombre, soit l'entier le plus proche inférieur ou égal au nombre. math.h
FMOD double fmod(double a,double b) Cette fonction retourne le reste d'une division de a/b. math.h
FCNTL int fcntl(int fildes, int cmd, ...); Cette fonction permet d'effectuer des opérations de contrôle sur un descripteur de fichier. fcntl.h
FMTMSG int fmtmsg(long classification, const char *label, int severity, const char *text, const char *action, const char *tag); Cette fonction permet d'afficher un message avec le format spécifié dans la sortie de console système et/ou la sortie d'erreur standard. fmtmsg.h
FNMATCH int fnmatch(const char *pattern, const char *string, int flags); Cette fonction permet de vérification la correspondance entre un fichier et un masque générique. fnmatch.h
FOPEN FILE *fopen(const char *nomfichier,const char *mode) Cette fonction effectue l'ouverture d'un fichier. stdio.h
FORK pid_t fork(void); Cette fonction permet de créer un processus fils. unistd.h
FPATHCONF long int pathconf(const char *path, int name); Cette fonction permet de demander les options de configuration d'un fichier avec un identificateur «Handle». unistd.h
FPRINTF int fprintf(FILE *ptrfichier,const char *texte,...) Cette fonction effectue l'écriture de texte selon un certain format dans un fichier. stdio.h
FPUTC int fputc(int car,FILE *ptrfichier) Cette fonction effectue l'écriture de caractère dans un fichier. stdio.h
FPUTS int fputs(const *str,FILE *ptrfichier) Cette fonction effectue l'écriture d'une chaîne de caractères dans un fichier. stdio.h
FPUTWC wint_t fputwc(wchar_t wc, FILE *stream); Cette fonction permet d'effectuer l'écriture de caractère Unicode dans un fichier. wchar.h
FPUTWS nt fputws(const wchar_t *ws, FILE *stream); Cette fonction permet d'effectuer l'écriture d'une chaîne de caractères Unicode dans un fichier. wchar.h
FREAD int fread(void *tampon,size_t taille,size_t n,FILE *ptrfichier) Cette fonction effectue la lecture d'un bloc de mémoire de taille n*taille octets dans un fichier. stdio.h
FREE void free(void *pointeurbloc) Cette procédure permet de libérer un bloc de mémoire. stdlib.h
FREOPEN FILE *freopen(const char *nomfichier,const char *mode,FILE *ptrfichier) Cette fonction ferme le fichier et réouvre un fichier en lui affectant un pointeur. stdio.h
FREXP double frexp(double x,double *ptrexposant) Cette fonction permet d'effectuer la séparation de la mantisse et de l'exposant. math.h
FSCANF int fscanf(FILE *ptrfichier,const *format,...) Cette fonction permet la lecture de texte suivant un certain format dans un fichier. stdio.h
FSEEK int fseek(FILE *ptrfichier,long offset,int base) Cette fonction permet de fixer la position du pointeur de fichier. stdio.h
FSEEKO int fseeko(FILE *stream, off_t offset, int whence); Cette fonction permet de fixer la position du pointeur de fichier en utilisant le type de données off_t. stdio.h
FSETPOS int fsetpos(FILE *ptrfichier,const fpos_t *pos) Cette fonction permet de fixer la position du pointeur de fichier. stdio.h
FSTAT int fstat(int fildes, struct stat *buf); Cette fonction permet de demander l'état d'un fichier. sys/stat.h
FSTATVFS int fstatvfs(int fildes, struct statvfs *buf); Cette fonction permet de demander les informations du système de fichiers en utilisant un identificateur de fichier. sys/statvfs.h
FSYNC int fsync(int fildes); Cette fonction permet d'effectuer une synchronisation d'un fichier. unistd.h
FTELL long ftell(FILE *ptrfichier) Cette fonction permet de connaitre la position du pointeur de fichier. stdio.h
FTELLO off_t ftello(FILE *stream); Cette fonction permet de connaître la position du pointeur de fichier en utilisant le type de données off_t. stdio.h
FTIME int ftime(struct timeb *tp); Cette fonction permet de retourner l'heure courante. sys/timeb.h
FTOK key_t ftok(const char *path, int id); Cette fonction permet d'effectuer la conversion d'un nom de fichier ainsi que son identificateur de projet en sa clef IPC système V. sys/ipc.h
FTRUNCATE int ftruncate(int fildes, off_t length); Cette fonction permet de changer la taille d'un fichier. unistd.h
FTRYLOCKFILE int ftrylockfile(FILE *file); Cette fonction permet de tenter d'acquérir l'objet de verrouillage interne associé avec le flux de données comme la fonction flockfile. stdio.h
FTW int ftw(const char *path, int (*fn)(const char *, const struct stat *ptr, int flag), int ndirs); Cette fonction permet d'effectuer la lecture d'une entrée de la hiérarchie de fichiers. ftw.h
FUNLOCKFILE void funlockfile(FILE *file); Cette fonction permet de libérer l'objet de verrouillage interne de flux de données. stdio.h
FWIDE int fwide(FILE *stream, int mode); Cette fonction permet de déterminer l'orientation de flux de données spécifié. wchar.h
FWPRINTF int fwprintf(FILE *stream, const wchar_t *format, ...); Cette fonction permet d'effectuer l'écriture de texte selon un certain format dans un fichier en utilisant une chaîne de caractères Unicode. wchar.h
FWRITE long fwrite(void *buf,size_t taille,size_t n,FILE *ptrfichier) Cette fonction effectue l'écriture d'un bloc de mémoire de taille n*taille octets dans un fichier. stdio.h
FWSCANF int fwscanf(FILE *stream, const wchar_t *format, ... ); Cette fonction permet la lecture de texte suivant un certain format dans un fichier avec des chaînes de caractères Unicode. wchar.h
GAMMA double gamma(double x); Cette fonction permet de calculer la fonction gamme réelle en utilisant un type de données réel de double précision. math.h
GCVT char *gcvt(double value, int ndigit, char *buf); Cette fonction permet de convertir un nombre à virgule flottante en une chaîne de caractères. stdlib.h
GETC int getc(FILE *ptrfichier) Cette fonction effectue la lecture d'un caractère dans un fichier. stdio.h
GETCHAR int getchar(void) Cette fonction effectue la lecture d'un caractère à partir de la console standard. stdio.h
GETCHAR_UNLOCKED int getchar_unlocked(void); Cette fonction permet d'effectuer la lecture d'un caractère à partir de la console standard sans verrouiller implicitement le flux de données. stdio.h
GETCONTEXT int getcontext(ucontext_t *ucp); Cette fonction permet de demander le contexte de l'utilisateur courant. ucontext.h
GETCWD char *getcwd(char *buf, size_t size); Cette fonction permet de demander le répertoire courant. unistd.h
GETC_UNLOCKED int getc_unlocked(FILE *stream); Cette fonction permet d'effectuer la lecture d'un caractère dans un fichier sans verrouiller implicitement le flux de données. stdio.h
GETDATE struct tm *getdate(const char *string); Cette fonction permet de demander la date courante. time.h
GETDTABLESIZE int getdtablesize(void); Cette fonction permet de demander la taille de la table du descripteur de fichier. unistd.h
GETEGID gid_t getegid(void); Cette fonction permet de demander l'identificateur de groupe effectif. unistd.h
GETENV int getenv(const char *vnom) Cette fonction effectue la lecture d'un variable d'environnement système. stdlib.h
GETEUID uid_t geteuid(void); Cette fonction permet de demander l'identificateur d'utilisateur effectif. unistd.h
GETGID gid_t getgid(void); Cette fonction permet de demander l'identificateur de groupe réel. unistd.h
GETGRENT struct group *getgrent(void); Cette fonction permet d'effectuer la lecture d'un enregistrement d'un groupe de fichier. grp.h
GETGRGID struct group *getgrgid(gid_t gid); Cette fonction permet de demander la structure de groupe à partir de son identificateur de groupe. grp.h
GETGRGID_R int getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize, struct group **result); Cette fonction permet de mettre à jour la structure de groupe spécifié et entrepose un pointeur sur cette structure à l'emplacement pointé par le résultat en se basant sur l'identificateur. grp.h
GETGRNAM struct group *getgrnam(const char *name); Cette fonction permet de demander la structure de groupe à partir de son nom. grp.h
GETGRNAM_R int getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize, struct group **result); Cette fonction permet de mettre à jour la structure de groupe spécifié et entrepose un pointeur sur cette structure à l'emplacement pointé par le résultat en se basant sur le nom. grp.h
GETGROUPS int getgroups(int gidsetsize, gid_t grouplist[]); Cette fonction permet de demander l'identificateur d'utilisateur supplémentaire de groupe. unistd.h
GETHOSTID long gethostid(void); Cette fonction permet de demander un identificateur pour l'hôte courant. unistd.h
GETITIMER int getitimer(int which, struct itimerval *value); Cette fonction permet de demander la valeur de l'intervalle de la minuterie. sys/time.h
GETLOGIN char *getlogin(void); Cette fonction permet de demander le nom de l'utilisateur actuellement connecté. unistd.h
GETLOGIN_R int getlogin_r(char *name, size_t namesize); Cette fonction permet de demander le nom de l'utilisateur actuellement connecté et copie le résultat dans le tampon spécifié. unistd.h
GETMSG int getmsg(int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *flagsp); Cette fonction permet de demander le contenu d'un message situé en tête de la file d'attente du flux de données spécifié et copie le contenu dans un ou plusieurs tampons. stropts.h
GETOPT int getopt(int argc, char * const argv[], const char *optstring); Cette fonction permet d'effectuer la lecture des paramètres d'une ligne de commande. stdio.h
GETPAGESIZE int getpagesize(void); Cette fonction permet de demander la taille de la page courante. unistd.h
GETPASS char *getpass(const char *prompt); Cette fonction permet d'effectuer la lecture d'un mot de passe. unistd.h
GETPGID pid_t getpgid(pid_t pid); Cette fonction permet de demander l'identificateur de groupe de processus pour un processus. unistd.h
GETPGRP pid_t getpgrp(void); Cette fonction permet de demander le groupe de processus d'un numéro de processus (PID). unistd.h
GETPID pid_t getpid(void); Cette fonction permet de demander l'identificateur de processus. unistd.h
GETPPID pid_t getppid(void); Cette fonction permet de demander le numéro de processus d'un processus parent. unistd.h
GETPRIORITY int getpriority(int which, id_t who); Cette fonction permet de demander la priorité du processus ou de l'utilisateur. sys/resource.h
GETPMSG int getpmsg(int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *bandp, int *flagsp); Cette fonction permet de recevoir le prochain message reçu du fichier de flux de données. stropts.h
GETPWNAM struct passwd *getpwnam(const char *name); Cette fonction permet de passer à un élément du fichier «/etc/passwd» avec un nom utilisateur spécifié. pwd.h
GETPWNAM_R int getpwnam_r(const char *nam, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); Cette fonction permet de passer à un élément du fichier «/etc/passwd» avec un nom utilisateur spécifié et copie le résultat dans le tampons spécifié. pwd.h
GETPWUID struct passwd *getpwuid(uid_t uid); Cette fonction permet de passer à un élément du fichier «/etc/passwd» avec un numéro d'utilisateur spécifié. pwd.h
GETPWUID_R int getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); Cette fonction permet de passer à un élément du fichier «/etc/passwd» avec un numéro d'utilisateur spécifié et copie le résultat dans le tampons spécifié. pwd.h
GETPWENT struct passwd *getpwent(void); Cette fonction permet de demander une entrée d'utilisateur dans la base de données. pwd.h
GETRLIMIT int getrlimit(int resource, struct rlimit *rlp); Cette fonction permet de demander le contrôle de la consommation maximale de ressources. sys/resource.h
GETRUSAGE int getrusage(int who, struct rusage *r_usage); Cette fonction permet de demander le niveau d'utilisation d'une ressource. sys/resource.h
GETS char *gets(char *buf) Cette fonction effectue la lecture d'une chaîne de caractères à partir de la console standard. stdio.h
GETSID pid_t getsid(pid_t pid); Cette fonction permet de demander l'identificateur de groupe de processus dans l'entête de session. unistd.h
GETSUBOPT int getsubopt(char **optionp, char * const *tokens, char **valuep); Cette fonction permet d'analyser les sous-options des paramètres dans une chaîne de caractères. stdlib.h
GETTIMEOFDAY int gettimeofday(struct timeval *tp, void *tzp); Cette fonction permet de demander l'heure actuelle, exprimée en secondes et en microsecondes depuis 00:00, le temps au coordonnée universel (UTC), le 1er janvier 1970, et l'entrepose dans la structure spécifié. sys/time.h
GETUID uid_t getuid(void); Cette fonction permet de demander l'identificateur de l'utilisateur. unistd.h
GETUTXENT struct utmpx *getutxent(void); Cette fonction permet de demander les entrées d'un compteur utilisateur dans la base de données. utmpx.h
GETUTXID struct utmpx *getutxid(const struct utmpx *id); Cette fonction permet d'effectuer une recherche à partir du point actuel dans la base de données. utmpx.h
GETUTXLINE struct utmpx *getutxline(const struct utmpx *line); Cette fonction permet d'effectuer une recherche à partir du point courant dans la base de données jusqu'à ce qu'elle trouve une entrée de type LOGIN_PROCESS ou USER_PROCESS ayant également une valeur ut_line correspondant à celle de la structure spécifié. utmpx.h
GETW int getw(FILE *stream); Cette fonction permet de demander un mot à partir d'un flux de données. stdio.h
GETWC wint_t getwc(FILE *stream); Cette fonction permet d'effectuer la lecture d'un caractère Unicode dans un fichier. wchar.h
GETWCHAR wint_t getwchar(void); Cette fonction permet d'effectuer la lecture d'un caractère Unicode à partir de la console standard. wchar.h
GETWD char *getwd(char *path_name); Cette fonction permet de demander le répertoire courant et le copier dans le tampon mémoire. unistd.h
GLOB int glob(const char *pattern, int flags, int(*errfunc)(const char *epath, int errno), glob_t *pglob); Cette fonction permet de générer un chemin intégrant les règles définies dans la spécification XCU. glob.h
GLOBFREE void globfree(glob_t *pglob); Cette fonction permet de libérer l'espace associé aux appellent précédent à la fonction glob. glob.h
GMTIME struct tm *gmtime(const time_t *sec) Cette fonction permet de convertir des secondes en date et heure. time.h
GMTIME_R struct tm *gmtime_r(const time_t *clock, struct tm *result); Cette fonction permet de convertir des secondes en date et heure et copie le résultat dans le tampon spécifié. time.h
GRANTPT int grantpt(int fildes); Cette fonction permet de donner les accès à un périphérique pseudo-terminal esclave. stdlib.h
HCREATE int hcreate(size_t nel); Cette fonction permet d'allouer suffisamment d'espace dans la table et doit être appelée avant l'utilisation de la fonction hsearch(). search.h
HDESTROY void hdestroy(void); Cette fonction permet de libérer la table de recherche. search.h
HSEARCH ENTRY *hsearch(ENTRY item, ACTION action); Cette fonction permet de rechercher dans la table de hachage. search.h
HYPOT double hypot(double x, double y); Cette fonction permet de calculer la longueur de l'hypoténuse d'un triangle avec un type de données réel de double précision. math.h
ICONV size_t iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft); Cette fonction permet de convertir la séquence de caractères d'un ensemble de codes dans le tableau spécifié, en une séquence de caractères correspondants dans un autre ensemble de codes dans le tableau spécifié. iconv.h
ICONV_CLOSE int iconv_close(iconv_t cd); Cette fonction permet de libérer les fonctions de conversion d'ensemble de codes. iconv.h
ICONV_OPEN iconv_t iconv_open(const char *tocode, const char * ); Cette fonction permet de demander un descripteur de conversion décrivant un ensemble de codes spécifié vers l'ensemble de codes spécifié. iconv.h
ILOGB int ilogb(double x) Cette fonction permet de retourner la partie exposante de paramètre spécifié. math.h
INDEX char *index(const char *s, int c); Cette fonction permet d'effectuer la recherche du premier caractère spécifié dans la chaîne de caractères spécifié. strings.h
INITSTATE char *initstate(unsigned int seed, char *state, size_t size); Cette fonction permet de redémarrer et changer le générateur de nombre pseudo-aléatoire. stdlib.h
INSQUE void insque(void *element, void *pred); Cette fonction permet d'insérer l'élément spécifié dans une file d'attente immédiatement après l'élément précédent spécifié. search.h
IOCTL int ioctl(int fildes, int request, ... /* arg */); Cette fonction permet de contrôler un périphérique de flux de données. stropts.h
ISALNUM int isalnum(int caractere) Cette fonction indique si le caractère est alphanumérique (A à Z et a à z). ctype.h
ISALPHA int isalpha(int c); Cette fonction indique si le caractère est alphabétique (A à Z et a à z). ctype.h
ISASTREAM int isastream(int fildes); Cette fonction permet de tester un descripteur de fichier. stropts.h
ISATTY int isatty(int fildes); Cette fonction permet d'indiquer si l'identificateur de fichier Handle est une connexion TTY. unistd.h
ISCNTRL int iscntrl(int caractere) Cette fonction indique si le caractère est un caractère de contrôle. ctype.h
ISDIGIT int isdigit(int caractere) Cette fonction indique si le caractère est un nombre. ctype.h
ISGRAPH int isgraph(int caractere) Cette fonction indique si le caractère est un caractère graphique. ctype.h
ISLOWER int islower(int caractere) Cette fonction indique si le caractère est une lettre minuscule. ctype.h
ISNAN int isnan(double x); Cette fonction permet de vérifier si le paramètre spécifié est un NaN. math.h
ISPRINT int isprint(int caractere) Cette fonction indique si le caractère est imprimable. ctype.h
ISPUNCT int ispunct(int caractere) Cette fonction indique si le caractère est un signe de ponctuation (!,?,...). ctype.h
ISSPACE int isspace(int caractere) Cette fonction indique si le caractère est un espace. ctype.h
ISUPPER int isupper(int caractere) Cette fonction indique si le caractère est une lettre majuscule. ctype.h
ISWALNUM int iswalnum(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est alphanumérique (A à Z et a à z). wchar.h
ISWALPHA int iswalpha(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est alphabétique (A à Z et a à z). wchar.h
ISWCNTRL int iswcntrl(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un caractère de contrôle. wchar.h
ISWCTYPE int iswctype(wint_t wc, wctype_t charclass); Cette fonction permet de vérifier si le caractère Unicode a la propriété décrite spécifié. wchar.h
ISWDIGIT int iswdigit(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un nombre. wchar.h
ISWGRAPH int iswgraph(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un caractère graphique. wchar.h
ISWLOWER int iswlower(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est une lettre minuscule. wchar.h
ISWPRINT int iswprint(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est imprimable. wchar.h
ISWPUNCT int iswpunct(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un signe de ponctuation (!,?,...). wchar.h
ISWSPACE int iswspace(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un espace. wchar.h
ISWUPPER int iswupper(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est une lettre majuscule. wchar.h
ISWXDIGIT int iswxdigit(wint_t wc); Cette fonction permet d'indiquer si le caractère Unicode est un nombre hexadécimal (0 à F). wchar.h
ISXDIGIT int isxdigit(int caractere) Cette fonction indique si le caractère est un nombre hexadécimal (0 à F). ctype.h
J0 double j0(double x); Cette fonction permet de retourner la fonction Bessel de j0. math.h
J1 double j1(double x); Cette fonction permet de retourner la fonction Bessel de j1. math.h
JN double jn(int n, double x); Cette fonction permet de retourner la fonction Bessel de jn. math.h
JRAND48 long int jrand48(unsigned short int xsubi[3]); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0 à 2 147 483 647 en utilisant les données de génération de nombre spécifié. stdlib.h
KILL int kill(pid_t pid, int sig); Cette fonction permet d'effectuer des commandes sur des processus. signal.h
KILLPG int killpg(pid_t pgrp, int sig); Cette fonction permet d'envoyer un signal à groupe de processus. signal.h
L64A char *l64a(long value); Cette fonction permet de convertir un entier 32 bits en une chaîne de caractères ASCII radix-64. stdlib.h
LABS long labs(long a) Cette fonction retourne la valeur absolue d'un entier de type «long». stdlib.h
LCHOWN int lchown(const char *path, uid_t owner, gid_t group); Cette fonction permet de changer le propriétaire et le groupe d'un lien symbolique. unistd.h
LCONG48 void lcong48(unsigned short int param[7]); Cette procédure initialise le générateur de nombre aléatoire d'une distribution uniforme en 48 bits. stdlib.h
LDEXP double ldexp(double m,int exp) Cette fonction retourne la valeur de produit par la puissance 2. math.h
LDIV ldiv_t ldiv(long a,long b) Cette fonction retourne le reste et le quotient séparément en effectuant de division de a par b. stdlib.h
LFIND void *lfind(const void *key, const void *base, size_t *nelp, size_t width, int (*compar)(const void *, const void *)); Cette fonction permet d'effectuer une recherche selon une méthode linéaire dans le tableau spécifié. search.h
LGAMMA double lgamma(double x); Cette fonction permet de retourner le logarithme d'une fonction «Gamma». math.h
LINK int link(const char *path1, const char *path2); Cette fonction permet d'ajouter un lien vers un fichier. unistd.h
LIO_LISTIO int lio_listio(int mode, struct aiocb * const list[], int nent, struct sigevent *sig); Cette fonction permet au processus appelant de lancer une liste de requêtes d'entrée/sortie avec un seul appel de fonction. aio.h
LOCKF int lockf(int fildes, int function, off_t size); Cette fonction permet de verrouiller un enregistrement dans des fichiers. unistd.h
LOCALECONV struct lconv *localeconv(void); Cette fonction permet de demander les informations de format numérique du poste de travail local. locale.h
LOCALTIME struct tm *localtime(const time_t *sec) Cette fonction permet de convertir des secondes en date et heure. time.h
LOCALTIME_R struct tm *localtime_r(const time_t *clock, struct tm *result); Cette fonction permet de convertir des secondes en date et heure et copie le résultat dans le tampon spécifié. time.h
LOG double log(double a) Cette fonction retourne le logarithme naturel ou népérien. math.h
LOG10 double log10(double a) Cette fonction retourne le logarithme décimal. math.h
LOG1P double log1p(double x); Cette fonction retourne le logarithme de 1 plus x avec des nombres réels de double précision. math.h
LOGB double logb(double x); Cette fonction permet de calculer l'exposant de l'expression spécifié, lequel est la partie intégral de logr|x|. math.h
LONGJMP void longjmp(jmp_buf env,int val) Cette procédure effectue la restauration de la pile dans un saut non local. setjmp.h
LRAND48 long int lrand48(void); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0 à 4 294 967 295. stdlib.h
LSEARCH void *lsearch(const void *key, void *base, size_t *nelp, size_t width, int (*compar)(const void *, const void *)); Cette fonction permet d'effectuer une recherche selon une méthode linéaire dans le tableau spécifié et si la valeur recherché n'est pas trouvé, elle l'ajoute à la fin du tableau. search.h
LSEEK off_t lseek(int fildes, off_t offset, int whence); Cette fonction permet d'effectuer le positionnement du pointeur de fichier Handle. unistd.h
LSTAT int lstat(const char *path, struct stat *buf); Cette fonction permet d'effectuer le positionnement du pointeur de fichier Handle. sys/stat.h
MAKECONTEXT void makecontext(ucontext_t *ucp, (void *func)(), int argc, ...); Cette fonction permet de modifier le contexte spécifié ayant été initialisé en utilisant la fonction getcontext(). ucontext.h
MALLOC void *malloc(size_t n) Cette fonction une allocation de mémoire dynamique de «n» octets. stdlib.h
MBLEN int mblen(const char *s, size_t n); Cette fonction permet de retourner la longueur d'une chaîne de caractères de format Unicode ou multi-octets. stdlib.h
MBRLEN size_t mbrlen(const char *s, size_t n, mbstate_t *ps); Cette fonction permet de retourner le nombre d'octets comprenant le caractère multi-octets spécifié. wchar.h
MBRTOWC size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps); Cette fonction permet de convertir un caractère multi-octets en caractère Unicode. wchar.h
MBSRTOWCS size_t mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps); Cette fonction permet de convertir une chaîne de caractères multi-octets en chaîne de caractères Unicode. wchar.h
MBSINIT int mbsinit(const mbstate_t *ps); Cette fonction permet de vérifier si l'objet pointé spécifié décrit un état de conversion initial. wchar.h
MBSTOWCS size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n); Cette fonction permet de convertir une chaîne de caractères de format multi-octets en Unicode. stdlib.h
MBTOWC int mbtowc(wchar_t *pwc, const char *s, size_t n); Cette fonction permet de convertir une chaîne de caractères de format multi-octets en Unicode. stdlib.h
MEMCHR void *memchr(const void *tampon, int caractere, size_t n) Cette fonction permet de rechercher un caractère dans le tampon de «n» octets. string.h
MEMCMP void *memcmp(const void *tamponrecherche, const void *tampondonnees, size_t n) Cette fonction permet de rechercher un tampon de recherche dans le tampon de données de «n» octets. string.h
MEMCPY void *memcpy(const void *tampondestination, const void *tamponsource, size_t n) Cette fonction permet de copier un tampon source dans un tampon de destination de «n» octets. string.h
MEMMOVE void *memmove(const void *tampondestination, const void *tamponsource, size_t n) Cette fonction permet de copier un tampon source dans un tampon de destination de «n» octets. string.h
MEMSET void *memset(const void *tampon, int caractere, size_t n) Cette fonction permet de remplir avec un caractère un tampon de «n» octets. string.h
MKDIR int mkdir(const char *path, mode_t mode); Cette fonction permet de créer un nouveau répertoire. sys/stat.h
MKFIFO int mkfifo(const char *path, mode_t mode); Cette fonction permet de créer un tube FIFO à l'emplacement spécifié. sys/stat.h
MKNOD int mknod(const char *path, mode_t mode, dev_t dev); Cette fonction permet de de créer un répertoire, un fichier régulier ou un spécial. sys/stat.h
MKSTEMP int mkstemp(char *template); Cette fonction permet de créer un fichier avec un nom unique en modifiant le paramètre de gabarit et en retournant son identificateur de fichier ouvert pour la lecture ou l'écriture en mode binaire. stdlib.h
MKTEMP char *mktemp(char *template); Cette fonction permet de générer un nom de fichier temporaire basé sur un gabarit spécifié. stdlib.h
MKTIME time_t *mktime(struct tm *ptrheure) Cette fonction permet de convertir des heures local en heures normalisé. time.h
MLOCK int mlock(const void * addr, size_t len); Cette fonction permet que toutes les pages contenant une partie de l'espace d'adressage du processus commencent à l'adresse spécifié et continue jusqu'à ce que la longueur d'octets soit résident jusqu'à ce qu'il soit déverrouillé ou jusqu'à ce que le processus quitte ou exécute une autre image de processus. sys/mman.h
MLOCKALL int mlockall(int flags); Cette fonction permet d'effectuer le verrouillage de l'espace d'adressage d'un processus en temps réel. sys/mman.h
MMAP void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off); Cette fonction permet d'établir une cartographie entre l'espace d'adressage d'un processus et un objet de fichier ou de mémoire partagée. sys/mman.h
MODF double modf(double x,double *entier) Cette fonction transforme un nombre réel en partie entière et en décimal (fraction). math.h
MPROTECT int mprotect(void *addr, size_t len, int prot); Cette fonction permet de fixer la protection de la cartographie mémoire. sys/mman.h
MQ_CLOSE int mq_close(mqd_t mqdes); Cette fonction permet de fermer la file d'attente de message. mqueue.h
MQ_GETATTR int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat); Cette fonction permet de demander les attributs de la file d'attente de message. mqueue.h
MQ_NOTIFY int mq_notify(mqd_t mqdes, const struct sigevent *notification); Cette fonction permet d'avertir un processus qu'un message est disponible. mqueue.h
MQ_OPEN mqd_t mq_open(const char *name, int oflag, ...); Cette fonction permet d'ouvrir une file d'attente de message. mqueue.h
MQ_RECEIVE ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio); Cette fonction permet de recevoir un message d'une file d'attente de message. mqueue.h
MQ_SEND int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio); Cette fonction permet d'envoyer un message à la file d'attente de message. mqueue.h
MQ_SETATTR int mq_setattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat); Cette fonction permet de fixer les attributs de file d'attente de message. mqueue.h
MQ_UNLINK int mq_unlink(const char *name); Cette fonction permet d'enlever un message de la file d'attente. mqueue.h
MRAND48 long int mrand48(void); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0 à 2 147 483 647. stdlib.h
MSGCTL int msgctl(int msqid, int cmd, struct msqid_ds *buf); Cette fonction permet d'effectuer des opérations de contrôle de messages XSI. sys/msg.h
MSGGET int msgget(key_t key, int msgflg); Cette fonction permet de demander l'identificateur de file d'attente de messages XSI. sys/msg.h
MSGRCV ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long int msgtyp, int msgflg); Cette fonction permet d'effectuer des opérations de réception de messages XSI. sys/msg.h
MSGSND int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); Cette fonction permet d'effectuer des opérations d'envoi de messages XSI. sys/msg.h
MSYNC int msync(void *addr, size_t len, int flags); Cette fonction permet d'effectuer la synchronisation de la mémoire avec l'entreposage physique. sys/mman.h
MUNLOCK int munlock(const void * addr, size_t len); Cette fonction permet d'effectuer le déverrouillage d'une plage d'espace d'adressage de processus. sys/mman.h
MUNLOCKALL int munlockall(void); Cette fonction permet d'effectuer le déverrouillage de l'espace d'adressage d'un processus en temps réel. sys/mman.h
MUNMAP int munmap(void *addr, size_t len); Cette fonction permet de décartographier les pages de mémoire. sys/mman.h
MVADD_WCH int mvadd_wch(int y, int x, const cchar_t *wch) Cette fonction permet d'écrire un caractère à la position (X,Y) dans la fenêtre. curses.h
MVWADD_WCH int mvwadd_wch(WINDOW *win, int y, int x, const cchar_t *wch) Cette fonction permet d'écrire un caractère à la position (X,Y) de la fenêtre spécifique. curses.h
MVADD_WCHNSTR int mvadd_wchnstr(int y, int x, const cchar_t *wchstr, int n) Cette fonction permet d'écrire une chaine de caractères d'une longueur spécifié à la position (X,Y) à une fenêtre. curses.h
MVADD_WCHSTR int mvadd_wchstr(int y, int x, const cchar_t *wchstr) Cette fonction permet d'écrire une chaine de caractères à la position (X,Y) à une fenêtre. curses.h
MVWADD_WCHNSTR int mvwadd_wchnstr(WINDOW *win, int y, int x, const cchar_t *wchstr, int n) Cette fonction permet d'écrire une chaine de caractères d'une longueur spécifié à la position (X,Y) à une fenêtre spécifique. curses.h
MVWADD_WCHSTR int mvwadd_wchstr(WINDOW *win, int y, int x, const cchar_t *wchstr) Cette fonction permet d'écrire une chaîne de caractères à la position (X,Y) à une fenêtre spécifique. curses.h
NANOSLEEP int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); Cette fonction permet de suspendre l'exécution d'un programme un délai très court spécifié en nanoseconde. time.h
NEXTAFTER double nextafter(double x, double y); Cette fonction permet d'effectuer le calcul de la prochaine de représentation de la valeur spécifié après une direction spécifié. math.h
NFTW int nftw(const char *path, int (*fn)(const char *, const struct stat *, int, struct FTW *), int depth, int flags); Cette fonction permet d'effectuer la lecture d'une entrée de la hiérarchie de fichiers. ftw.h
NICE int nice(int incr); Cette fonction permet de modifier les préférences de planification de tâche du processus courant. unistd.h
NL_LANGINFO char *nl_langinfo(nl_item item); Cette fonction permet de demander des informations sur la configuration et la langue. langinfo.h
NRAND48 long int nrand48(unsigned short int xsubi[3]); Cette fonction permet de retourner un nombre aléatoire d'une distribution dans l'intervalle de 0 à 4 294 967 295 en utilisant les données de génération de nombre spécifié. stdlib.h
OPEN int open(const char *path, int oflag, ... ); Cette fonction permet d'effectuer l'ouverture d'un fichier en lecture et écriture. fcntl.h
OPENDIR DIR *opendir(const char *dirname); Cette fonction permet d'ouvrir un répertoire. dirent.h
OPENLOG void openlog(const char *ident, int logopt, int facility); Cette fonction permet d'ouvrir une connexion au journal de bord. syslog.h
PATHCONF long int pathconf(const char *path, int name); Cette fonction permet de demander les options de configuration d'un fichier. unistd.h
PAUSE int pause(void); Cette fonction permet de suspendre l'exécution du processus courant jusqu'à un signal soit reçu. unistd.h
PCLOSE int pclose(FILE *stream); Cette fonction permet de fermer un processus à lequel lui est associé une ressource de fichier Handle précédemment attribué par une fonction popen. stdio.h
PERROR void perror(const char *message) Cette procédure envoi un message d'erreur sur la sortie standard d'erreur. stdio.h
PIPE int pipe(int fildes[2]); Cette fonction permet d'effectuer la création d'un canal entre processus. unistd.h
POLL int poll(struct pollfd fds[], nfds_t nfds, int timeout); Cette fonction permet d'attendre après un événement de façon à fournir aux applications un mécanisme mutiplexe d'entrée/sortie à un ensemble de descripteurs de fichier. poll.h
POPEN FILE *popen(const char *command, const char *mode); Cette fonction permet d'effectuer l'ouverture d'un tube de processus d'entrée/sortie. stdio.h
POW double pow(double x,double y) Cette fonction retourne le calcul de x à la puissance y. math.h
PREAD ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); Cette fonction permet d'effectuer une lecture dans un fichier. unistd.h
PRINTF int printf(const char *texte,...) Cette fonction effectue l'écriture de texte selon un certain format sur la console. stdio.h
PTHREAD_ATFORK int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); Cette fonction permet d'enregistrer un gestionnaire de fork. unistd.h
PTHREAD_ATTR_DESTROY int pthread_attr_destroy(pthread_attr_t *attr); Cette fonction permet de détruire un objet d'attributs d'un processus léger. pthread.h
PTHREAD_ATTR_GETDETACHSTATE int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate); Cette fonction permet de demander la valeur d'un attribut spécifié. pthread.h
PTHREAD_ATTR_GETGUARDSIZE int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize); Cette fonction permet de demander l'attribut spécifié dans l'objet spécifié. pthread.h
PTHREAD_ATTR_GETINHERITSCHED int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched); Cette fonction permet de demander l'attribut dans le paramètre spécifié. pthread.h
PTHREAD_ATTR_GETSCHEDPARAM int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param); Cette fonction permet de demander l'attribut de paramètre de planification spécifié. pthread.h
PTHREAD_ATTR_GETSCHEDPOLICY int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy); Cette fonction permet de demander la politique de planification pour l'attribut spécifié. pthread.h
PTHREAD_ATTR_GETSCOPE int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope); Cette fonction permet de demander l'attribution d'étendue de contention dans l'objet spécifié. pthread.h
PTHREAD_ATTR_GETSTACKADDR int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr); Cette fonction permet de demander l'attribut de création d'un processus léger dans l'objet spécifié. pthread.h
PTHREAD_ATTR_GETSTACKSIZE int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize); Cette fonction permet de demander la taille d'une pile d'attribut pour l'objet spécifié. pthread.h
PTHREAD_ATTR_INIT int pthread_attr_init(pthread_attr_t *attr); Cette fonction permet d'initialiser un objet d'attributs de processus léger. pthread.h
PTHREAD_ATTR_SETDETACHSTATE int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); Cette fonction permet d'entreposer la valeur d'un attribut spécifié. pthread.h
PTHREAD_ATTR_SETGUARDSIZE int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); Cette fonction permet de fixer l'attribut spécifié dans l'objet spécifié. pthread.h
PTHREAD_ATTR_SETINHERITSCHED int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched); Cette fonction permet de fixer l'attribut dans le paramètre spécifié. pthread.h
PTHREAD_ATTR_SETSCHEDPARAM int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param); Cette fonction permet de fixer l'attribut de paramètre de planification spécifié. pthread.h
PTHREAD_ATTR_SETSCHEDPOLICY int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy); Cette fonction permet de fixer la politique de planification pour l'attribut spécifié. pthread.h
PTHREAD_ATTR_SETSCOPE int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope); Cette fonction permet de fixer l'attribution d'étendue de contention dans l'objet spécifié. pthread.h
PTHREAD_ATTR_SETSTACKADDR int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr); Cette fonction permet de fixer l'attribut de création d'un processus léger dans l'objet spécifié. pthread.h
PTHREAD_ATTR_SETSTACKSIZE int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); Cette fonction permet de fixer la taille d'une pile d'attribut pour l'objet spécifié. pthread.h
PTHREAD_CANCEL int pthread_cancel(pthread_t thread); Cette fonction permet d'annuler l'exécution d'un processus léger. pthread.h
PTHREAD_CLEANUP_POP void pthread_cleanup_pop(int execute); Cette fonction permet de dépiler la routine en haut de la pile de nettoyage d'annulation du processus léger appelant et l'appelle éventuellement (si l'exécution spécifié est différent de zéro). pthread.h
PTHREAD_CLEANUP_PUSH void pthread_cleanup_push(void (*routine)(void*), void *arg); Cette fonction permet d'empiler la routine du gestionnaire de nettoyage d'annulation spécifiée sur la pile de nettoyage d'annulation de processus léger appelant. pthread.h
PTHREAD_COND_BROADCAST int pthread_cond_broadcast(pthread_cond_t *cond); Cette fonction permet de débloquer tous les processus léger actuellement bloqués sur la condition spécifié. pthread.h
PTHREAD_COND_DESTROY int pthread_cond_destroy(pthread_cond_t *cond); Cette fonction permet de détruire la variable de condition spécifié. pthread.h
PTHREAD_COND_INIT int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); Cette fonction permet d'initialiser la variable condition référencé spécifié avec les attributs référencé spécifié. pthread.h
PTHREAD_COND_SIGNAL int pthread_cond_signal(pthread_cond_t *cond); Cette fonction permet de débloquer au moins l'un des processus léger étant bloqués sur la variable de condition spécifié. pthread.h
PTHREAD_COND_TIMEDWAIT int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); Cette fonction permet d'attendre après un bloc de variable de condition et retourne une erreur si un délai est passé. pthread.h
PTHREAD_COND_WAIT int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); Cette fonction permet d'attendre après un bloc de variable de condition. pthread.h
PTHREAD_CONDATTR_DESTROY int pthread_condattr_destroy(pthread_condattr_t *attr); Cette fonction permet de détruire l'objet d'attributs de la variable de condition. pthread.h
PTHREAD_CONDATTR_GETPSHARED int pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared); Cette fonction permet de demander la valeur de l'attribut de processus partagé à partir de l'objet d'attribut spécifié. pthread.h
PTHREAD_CONDATTR_INIT int pthread_condattr_init(pthread_condattr_t *attr); Cette fonction permet d'initialiser une variable d'attributs spécifié avec la valeur par défaut pour tous les attributs définis par l'intégration. pthread.h
PTHREAD_CONDATTR_SETPSHARED int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared); Cette fonction permet de fixer l'attribut de processus partagé dans un objet d'attributs initialisé spécifié. pthread.h
PTHREAD_CREATE int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg); Cette fonction permet de créer un processus léger. pthread.h
PTHREAD_DETACH int pthread_detach(pthread_t thread); Cette fonction permet de détacher un processus léger. pthread.h
PTHREAD_EQUAL int pthread_equal(pthread_t t1, pthread_t t2); Cette fonction permet de comparer 2 identificateurs de processus léger. pthread.h
PTHREAD_EXIT void pthread_exit(void *value_ptr); Cette fonction permet de terminer un processus léger. pthread.h
PTHREAD_GETCONCURRENCY int pthread_getconcurrency(void); Cette fonction permet de demander le niveau de concurrence. pthread.h
PTHREAD_GETSCHEDPARAM int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param); Cette fonction permet de demander la politique de planification et les paramètres de planification des processus léger individuels au sein d'un processus multi-processus léger. pthread.h
PTHREAD_GETSPECIFIC void *pthread_getspecific(pthread_key_t key); Cette fonction permet de demander la valeur actuellement liée à la clef spécifiée pour le compte du processus léger appelant. pthread.h
PTHREAD_JOIN int pthread_join(pthread_t thread, void **value_ptr); Cette fonction permet de suspendre l'exécution d'un processus léger appelant jusqu'à ce que le processus léger destinataire se termine, sauf si le processus léger destinataire est déjà terminé. pthread.h
PTHREAD_KEY_CREATE int pthread_key_create(pthread_key_t *key, void (*destructor)(void*)); Cette fonction permet de créer une clef de données spécifique au processus léger visible pour tous les processus léger du processus. pthread.h
PTHREAD_KEY_DELETE int pthread_key_delete(pthread_key_t key); Cette fonction permet de supprimer une clef de données spécifique au processus léger retournée par pthread_key_create(). pthread.h
PTHREAD_KILL int pthread_kill(pthread_t thread, int sig); Cette fonction permet d'envoyer un signal à un processus léger. signal.h
PTHREAD_MUTEX_DESTROY int pthread_mutex_destroy(pthread_mutex_t *mutex); Cette fonction permet de détruire l'objet Mutex spécifié. pthread.h
PTHREAD_MUTEX_GETPRIOCEILING int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex, int *prioceiling); Cette fonction permet de demander la limite de priorité courante du Mutex. pthread.h
PTHREAD_MUTEX_INIT int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); Cette fonction permet d'initialiser l'objet Mutex spécifié avec l'attribut spécifié. pthread.h
PTHREAD_MUTEX_LOCK int pthread_mutex_lock(pthread_mutex_t *mutex); Cette fonction permet de verrouiller un Mutex spécifié. pthread.h
PTHREAD_MUTEX_SETPRIOCEILING int pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int prioceiling, int *old_ceiling); Cette fonction permet de verrouiller un Mutex spécifié s'il est déverrouillé, ou bloque jusqu'à ce qu'il réussisse à verrouiller le Mutex, puis il modifie la limite de priorité du Mutex et libère le Mutex. pthread.h
PTHREAD_MUTEX_TRYLOCK int pthread_mutex_trylock(pthread_mutex_t *mutex); Cette fonction permet de verrouiller un Mutex spécifié mais retourne immédiatement s'il est déjà verrouillé. pthread.h
PTHREAD_MUTEX_UNLOCK int pthread_mutex_unlock(pthread_mutex_t *mutex); Cette fonction permet de déverrouiller un Mutex spécifié. pthread.h
PTHREAD_MUTEXATTR_DESTROY int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); Cette fonction permet de détruire un objet d'attribut Mutex. pthread.h
PTHREAD_MUTEXATTR_GETPRIOCEILING int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling); Cette fonction permet de demander la limite de l'attribut de priorité d'un objet Mutex spécifié. pthread.h
PTHREAD_MUTEXATTR_GETPROTOCOL int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol); Cette fonction permet de demander l'attribut de protocole d'un objet d'attribut Mutex. pthread.h
PTHREAD_MUTEXATTR_GETPSHARED int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared); Cette fonction permet de demander la valeur de l'attribut de partage de processus à partir de l'objet d'attribut spécifié. pthread.h
PTHREAD_MUTEXATTR_GETTYPE int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type); Cette fonction permet de demander le type d'attribut de Mutex. pthread.h
PTHREAD_MUTEXATTR_INIT int pthread_mutexattr_init(pthread_mutexattr_t *attr); Cette fonction permet d'initialiser un objet d'attribut Mutex avec la valeur par défaut pour tous les attributs définis par l'intégration. pthread.h
PTHREAD_MUTEXATTR_SETPRIOCEILING int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling); Cette fonction permet de demander la limite de l'attribut de priorité d'un objet Mutex spécifié. pthread.h
PTHREAD_MUTEXATTR_SETPROTOCOL int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol); Cette fonction permet de demander l'attribut de protocole d'un objet d'attribut Mutex. pthread.h
PTHREAD_MUTEXATTR_SETPSHARED int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared); Cette fonction permet de fixer l'attribut de partage de processus dans un objet d'attributs initialisé spécifié. pthread.h
PTHREAD_MUTEXATTR_SETTYPE int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type); Cette fonction permet de fixer le type d'attribut de Mutex. pthread.h
PTHREAD_ONCE int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)); Cette fonction permet d'appeler init_routine() sans paramètre s'il s'agit du premier appel au processus léger dans un processus. pthread.h
PTHREAD_RWLOCK_DESTROY int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); Cette fonction permet de détruire l'objet de verrouillage en lecture/écriture spécifié et libère toutes les ressources utilisées par le verrou. pthread.h
PTHREAD_RWLOCK_INIT int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); Cette fonction permet d'initialiser le verrouillage en lecture/écriture spécifié avec les attributs spécifié. pthread.h
PTHREAD_RWLOCK_RDLOCK int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); Cette fonction permet d'appliquer un verrouillage en lecture au verrou en lecture/écriture spécifié. pthread.h
PTHREAD_RWLOCK_TRYRDLOCK int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); Cette fonction permet d'appliquer un verrouillage en lecture au verrou en lecture/écriture spécifié mais échoue si un processus léger détient un verrou en écriture ou si des écritures sont bloqués. pthread.h
PTHREAD_RWLOCK_TRYWRLOCK int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); Cette fonction permet d'appliquer un verrouillage en écriture au verrou en lecture/écriture spécifié mais échoue si un processus léger détient un verrou en écriture ou si des écritures sont bloqués. pthread.h
PTHREAD_RWLOCK_UNLOCK int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); Cette fonction permet de déverrouiller un objet de verrou en lecture/écriture. pthread.h
PTHREAD_RWLOCK_WRLOCK int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); Cette fonction permet d'appliquer un verrouillage en écriture au verrou en lecture/écriture spécifié. pthread.h
PTHREAD_RWLOCKATTR_DESTROY int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr); Cette fonction permet de détruire un objet d'attributs de verrouillage en lecture/écriture. pthread.h
PTHREAD_RWLOCKATTR_GETPSHARED int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr, int *pshared); Cette fonction permet de demander la valeur de l'attribut de partage de processus à partir de l'objet d'attributs initialisé spécifié. pthread.h
PTHREAD_RWLOCKATTR_INIT int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); Cette fonction permet d'initialiser un attribut spécifié de verrouillage en lecture/écriture avec la valeur par défaut pour tous les attributs définis par l'intégration. pthread.h
PTHREAD_RWLOCKATTR_SETPSHARED int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared); Cette fonction permet de fixer l'attribut de partage de processus dans un objet d'attributs initialisé spécifié. pthread.h
PTHREAD_SELF pthread_t pthread_self(void); Cette fonction permet de demander l'identificateur de processus léger de l'appelant. pthread.h
PTHREAD_SETCANCELSTATE int pthread_setcancelstate(int state, int *oldstate); Cette fonction permet de fixer l'état d'annulation du processus léger appelant à l'état spécifié et retourne l'état d'annulation précédent à l'emplacement référencé spécifié. pthread.h
PTHREAD_SETCANCELTYPE int pthread_setcanceltype(int type, int *oldtype); Cette fonction permet de fixer l'état d'annulation du processus léger appelant sur le type spécifié et retourne le type d'annulation précédent à l'emplacement référencé spécifié. pthread.h
PTHREAD_SETCONCURRENCY int pthread_setconcurrency(int new_level); Cette fonction permet de fixer le niveau de concurrence. pthread.h
PTHREAD_SETSCHEDPARAM int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param); Cette fonction permet de demander la politique de planification et les paramètres de planification des processus léger individuels au sein d'un processus multi-processus léger. pthread.h
PTHREAD_SETSPECIFIC int pthread_setspecific(pthread_key_t key, const void *value); Cette fonction permet d'associer une valeur spécifique au processus léger à une clef obtenue via un appel précédent pthread_key_create(). pthread.h
PTHREAD_SIGMASK int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset); Cette fonction permet d'examiner et de changer les signaux bloqués. signal.h
PTHREAD_TESTCANCEL void pthread_testcancel(void); Cette fonction permet de créer un point d'annulation dans le processus léger appelant. pthread.h
PTSNAME char *ptsname(int fildes); Cette fonction permet de demander le nom d'un périphérique pseudo-terminal esclave. stdlib.h
PUTC int putc(int car,FILE *ptrfichier) Cette fonction effectue l'écriture de caractère dans un fichier. stdio.h
PUTCHAR int putchar(int caractere) Cette fonction effectue l'écriture de caractère sur la console. stdio.h
PUTCHAR_UNLOCKED int putchar_unlocked(int c); Cette fonction permet d'effectuer l'écriture d'un caractère sur la console sans verrouiller implicitement le flux de données. stdio.h
PUTC_UNLOCKED int putc_unlocked(int c, FILE *stream); Cette fonction permet d'effectuer l'écriture d'un caractère dans un fichier sans verrouiller implicitement le flux de données. stdio.h
PUTENV int putenv(char *string); Cette fonction permet de changer la valeur d'une variable d'environnement et si elle n'existe pas dans créer une nouvelle. stdlib.h
PUTMSG int putmsg(int fildes, const struct strbuf *ctlptr, const struct strbuf *dataptr, int flags); Cette fonction permet de créer un message à partir d'un ou des tampons de processus et envoie le message à un fichier de flux de données. stropts.h
PUTPMSG int putpmsg(int fildes, const struct strbuf *ctlptr, const struct strbuf *dataptr, int band, int flags); Cette fonction permet de créer un message à partir d'un ou des tampons de processus et envoie le message à un fichier de flux de données dans différentes bandes de priorité. stropts.h
PUTS int puts(const char *texte) Cette fonction effectue l'écriture d'une chaîne de caractères sur la console. stdio.h
PUTUTXLINE struct utmpx *pututxline(const struct utmpx *utmpx); Cette fonction permet de mettre une entrée dans les comptes utilisateur de la base de données. utmpx.h
PUTW int putw(int w, FILE *stream); Cette fonction permet d'écrire un mot sur le flux de données. stdio.h
PUTWC wint_t putwc(wchar_t wc, FILE *stream); Cette fonction permet d'effectuer l'écriture de caractère Unicode dans un fichier. wchar.h
PUTWCHAR wint_t putwchar(wchar_t wc); Cette fonction permet d'effectuer l'écriture de caractère Unicode sur la console. wchar.h
PWRITE ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); Cette fonction permet d'écrire dans un fichier. unistd.h
QSORT void qsort(void *tableau,size_t n,size_t taille,int (*comp)(const void *px1,const void *px2) Cette procédure permet d'effectuer une tri d'un tableau avec la méthode «QuickSort». stdlib.h
RAISE int raise(int signal) Cette fonction envoi un signal programme s'exécutant. signal.h
RAND int rand(void) Cette fonction retourne un nombre pseudo-aléatoire entier. stdlib.h
RANDOM long random(void); Cette fonction permet de retourner un nombre pseudo-aléatoire. stdlib.h
RAND_R int rand_r(unsigned int *seed); Cette fonction permet de retourner un nombre pseudo-aléatoire entier et place le résultat de l'échantillonnage dans le tampon spécifié. stdlib.h
READ ssize_t read(int fildes, void *buf, size_t nbyte); Cette fonction permet d'effectuer la lecture d'un fichier. unistd.h
READDIR struct dirent *readdir(DIR *dirp) Cette fonction permet de lire une entrée de répertoire précédemment ouvert par «opendir». dirent.h
READDIR_R int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result); Cette fonction permet de lire une entrée de répertoire précédemment ouvert par «opendir» et copie le résultat dans la structure spécifié. dirent.h
READLINK int readlink(const char *path, char *buf, size_t bufsize); Cette fonction permet de lire la valeur d'un fichier de lien symbolique. unistd.h
READV ssize_t readv(int fildes, const struct iovec *iov, int iovcnt); Cette fonction permet d'effectuer le lecture d'un vecteur dans un fichier. sys/uio.h
REALLOC void *realloc(void *tampon,size_t taille) Cette fonction permet de changer la taille d'un bloc de mémoire dynamique. stdlib.h
REALPATH char *realpath(const char *file_name, char *resolved_name); Cette fonction permet de convertir un chemin de répertoire relatif en chemin de répertoire absolue. stdlib.h
REGCMP char *regcmp(const char *string1 , ... /*, (char *)0 */); Cette fonction permet de compiler une expression régulière constitué de paramètres concaténés et retourne un pointeur vers sa forme compilé. libgen.h
REGCOMP int regcomp(regex_t *preg, const char *pattern, int cflags); Cette fonction permet de compiler l'expression régulière contenue dans la chaîne de caractères spécifié et copie le résultat dans la structure spécifié. regex.h
REGERROR size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size); Cette fonction permet de demander la chaîne de caractères correspondant aux codes d'erreur retourné par regcomp() et regexec(). regex.h
REGEX char *regex(const char *re, const char *subject , ... ); Cette fonction permet d'exécuter un modèle compilé par rapport à la chaîne de caractères du sujet. libgen.h
REGEXEC int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags); Cette fonction permet de comparer la chaîne de caractères terminé par le caractère NULL spécifié avec l'expression régulière compilée initialiser par un appel précédent à regcomp(). regex.h
REGFREE void regfree(regex_t *preg); Cette fonction permet de libérer toute la mémoire alloué par une fonction regcomp(). regex.h
REMAINDER double remainder(double x, double y); Cette fonction permet de retourner le restant d'un nombre réel r = x - ny quand y est différent de 0. math.h
REMOVE int remove(const char *nomfichier) Cette fonction permet d'effacer un fichier. stdio.h
REMQUE void remque(void *element); Cette fonction permet d'enlever un élément de le file d'attente. search.h
RENAME int rename(const char *anciennom,const char *nouveaunom) Cette fonction permet de renommer un fichier. stdio.h
REWIND void rewind(FILE *ptrfichier) Cette procédure ramène le pointeur de fichier au début de ce fichier. stdio.h
REWINDDIR void rewinddir(DIR *dirp); Cette fonction permet de se positionner sur la première entrée de répertoire précédemment ouvert par «opendir». dirent.h
RE_COMP char *re_comp(const char *string); Cette fonction permet de convertir une chaîne de caractères d'expression régulière (RE) en une forme interne adaptée à la correspondance de modèle. re_comp.h
RE_EXEC int re_exec(const char *string); Cette fonction permet de comparer la chaîne de caractères pointée par la chaîne de caractères avec la dernière expression régulière passée à re_comp(). re_comp.h
RINDEX char *rindex(const char *s, int c); Cette fonction permet d'effectuer la recherche du dernière caractère spécifié dans la chaîne de caractères spécifié. strings.h
RINT double rint(double x); Cette fonction permet de retourner la valeur intégrale (représentée par un double) la plus proche de l'expression spécifié dans la direction du mode d'arrondissement actuel. math.h
RMDIR int rmdir(const char *path); Cette fonction permet de supprimer un répertoire. unistd.h
SBRK void *sbrk(intptr_t incr); Cette fonction permet de changer l'espace d'allocation. unistd.h
SCALB double scalb(double x, double n); Cette fonction permet de demander l'arrondissement d'un facteur d'échelle si elle effectue correctement l'arrondit du nombre réel. math.h
SCANF int scanf(const *format,...) Cette fonction permet la lecture de texte suivant un certain format dans une console standard. stdio.h
SCHED_GET_PRIORITY_MAX int sched_get_priority_max(int policy); Cette fonction permet de demander la limite de priorité maximum. sched.h
SCHED_GET_PRIORITY_MIN int sched_get_priority_min(int policy); Cette fonction permet de demander la limite de priorité minimum. sched.h
SCHED_GETPARAM int sched_getparam(pid_t pid, struct sched_param *param); Cette fonction permet de demander les paramètres du planificateur. sched.h
SCHED_GETSCHEDULER int sched_getscheduler(pid_t pid); Cette fonction permet de demander la politique du planificateur. sched.h
SCHED_RR_GET_INTERVAL int sched_rr_get_interval(pid_t pid, struct timespec *interval); Cette fonction permet de demander la limite de temps d'exécution. sched.h
SCHED_SETPARAM int sched_setparam(pid_t pid, const struct sched_param *param); Cette fonction permet de fixer les paramètres du planificateur. sched.h
SCHED_SETSCHEDULER int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param); Cette fonction permet de fixer la politique et les paramètres du planificateur. sched.h
SCHED_YIELD int sched_yield(void); Cette fonction permet de forcer le processus léger courant à abandonner le processeur jusqu'à ce qu'il redevienne en tête de sa liste de processus léger. sched.h
SEED48 void srand48(long int seedval); Cette procédure initialise le générateur de nombre aléatoire réentrant en 48 bits. stdlib.h
SEEKDIR void seekdir(DIR *dirp, long int loc); Cette fonction permet de fixer la position de lecture dans le flux de données de répertoire précédemment ouvert par «opendir». dirent.h
SELECT int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout); Cette fonction permet d'indiquer lequel des descripteurs de fichiers spécifiés est prêt pour la lecture, prêt pour l'écriture ou a une condition d'erreur en attente. sys/time.h
SEMCTL int semctl(int semid, int semnum, int cmd, ...); Cette fonction permet d'effectuer des opérations de contrôle des sémaphores. sys/sem.h
SEMGET int semget(key_t key, int nsems, int semflg); Cette fonction permet de demander l'ensemble des sémaphores. sys/sem.h
SEMOP int semop(int semid, struct sembuf *sops, size_t nsops); Cette fonction permet d'effectuer des opérations de sémaphores. sys/sem.h
SEM_CLOSE int sem_close(sem_t *sem); Cette fonction permet de fermer la sémaphore spécifié. semaphoreh.htm
SEM_DESTROY int sem_destroy(sem_t *sem); Cette fonction permet de détruire la sémaphore spécifié. semaphoreh.htm
SEM_GETVALUE int sem_getvalue(sem_t *sem, int *sval); Cette fonction permet de demander la valeur d'une sémaphore. semaphoreh.htm
SEM_INIT int sem_init(sem_t *sem, int pshared, unsigned int value); Cette fonction permet d'initialiser une sémaphore. semaphoreh.htm
SEM_OPEN sem_t *sem_open(const char *name, int oflag, ...); Cette fonction permet d'initialiser et d'ouvrir une sémaphore spécifié. semaphoreh.htm
SEM_POST int sem_post(sem_t *sem); Cette fonction permet de déverrouiller une sémaphore. semaphoreh.htm
SEM_TRYWAIT int sem_trywait(sem_t *sem); Cette fonction permet de verrouiller la sémaphore spécifié uniquement si la sémaphore n'est pas actuellement verrouillé. semaphoreh.htm
SEM_UNLINK int sem_unlink(const char *name); Cette fonction permet d'enlever la sémaphore spécifié. semaphoreh.htm
SEM_WAIT int sem_wait(sem_t *sem); Cette fonction permet de verrouiller la sémaphore. semaphoreh.htm
SETBUF void setbuf(FILE *ptrfichier,char *tampon) Cette procédure crée un tampon de fichier. stdio.h
SETCONTEXT int setcontext(const ucontext_t *ucp); Cette fonction permet de fixer le contexte de l'utilisateur courant. ucontext.h
SETGID int setgid(gid_t gid); Cette fonction permet de fixer l'identificateur de groupe réel et effectif pour un processus. unistd.h
SETGRENT void setgrent(void); Cette fonction permet de fixer le contenu d'un enregistrement d'un groupe de fichier. grp.h
SETITIMER int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue); Cette fonction permet de fixer la valeur de l'intervalle de la minuterie. sys/time.h
SETJMP int setjmp(jmp_buf env) Cette fonction effectue la sauvegarde de la pile. setjmp.h
SETKEY void setkey(const char *key); Cette fonction permet de fixer la clef d'encodage. stdlib.h
SETLOCALE char *setlocale(int category, const char *locale); Cette fonction permet de modifier d'effectuer des requêtes sur le programme locale. locale.h
SETLOGMASK int setlogmask(int maskpri); Cette fonction permet de fixer le masque de priorité de journal de bord. syslog.h
SETPGID int setpgid(pid_t pid, pid_t pgid); Cette fonction permet de fixer l'identificateur de groupe de processus du processus courant. unistd.h
SETPGRP pid_t setpgrp(void); Cette fonction permet de fixer l'identificateur de groupe de processus. unistd.h
SETPRIORITY int setpriority(int which, id_t who, int nice); Cette fonction permet de modifier la priorité du processus et de l'utilisateur. sys/resource.h
SETPWENT void setpwent(void); Cette fonction permet de fixer la fonction des utilisateurs de la base de données. pwd.h
SETREGID int setregid(gid_t rgid, gid_t egid); Cette fonction permet de fixer l'identificateur de groupe réel et effectif. unistd.h
SETREUID int setreuid(uid_t ruid, uid_t euid); Cette fonction permet de fixer l'identificateur d'utilisateur réel et effectif. unistd.h
SETRLIMIT int setrlimit(int resource, const struct rlimit *rlp); Cette fonction permet de fixer le contrôle de la consommation maximale de ressources. sys/resource.h
SETSID pid_t setsid(void); Cette fonction permet de fixer l'identificateur de session du processus courant. unistd.h
SETSTATE char *setstate(const char *state); Cette fonction permet d'échanger l'état des tableaux de générateur de nombre pseudo-aléatoire. stdlib.h
SETUID int setuid(uid_t uid); Cette fonction permet de fixer l'identificateur d'utilisateur réel et effectif d'un processus. unistd.h
SETUTXENT void setutxent(void); Cette fonction permet de réinitialiser la base de de données de compte utilisateur à sa première entrée. utmpx.h
SETVBUF int setvbuf(FILE *ptrfichier,char *tampon,int mode,size_t taille) Cette fonction contrôle la taille d'un tampon du type de tamporisation du fichier. stdio.h
SHMAT void *shmat(int shmid, const void *shmaddr, int shmflg); Cette fonction permet d'effectuer une opération d'attachement de mémoire partagé. sys/shm.h
SHMCTL int shmctl(int shmid, int cmd, struct shmid_ds *buf); Cette fonction permet d'effectuer une opération de contrôle de mémoire partagé. sys/shm.h
SHMDT int shmdt(const void *shmaddr); Cette fonction permet d'effectuer une opération de détachement de mémoire partagé. sys/shm.h
SHMGET int shmget(key_t key, size_t size, int shmflg); Cette fonction permet de demander le segment de mémoire partagé sys/shm.h
SHM_OPEN int shm_open(const char *name, int oflag, mode_t mode); Cette fonction permet d'ouvrir un objet de mémoire partagé. sys/mman.h
SHM_UNLINK int shm_unlink(const char * name); Cette fonction permet d'enlever un objet de mémoire partagé. sys/mman.h
SIGACTION int sigaction(int sig, const struct sigaction *act, struct sigaction *oact); Cette fonction permet d'effectuer la gestion détaillé d'un signal. signal.h
SIGADDSET int sigaddset(sigset_t *set, int signo); Cette fonction permet d'ajouter un signal à un ensemble de signal. signal.h
SIGALTSTACK int sigaltstack(const stack_t *ss, stack_t *oss); Cette fonction permet de fixer et/ou demander le signal de contexte de pile alternatif. signal.h
SIGDELSET int sigdelset(sigset_t *set, int signo); Cette fonction permet de supprimer un signal d'un ensemble de signal. signal.h
SIGEMPTYSET int sigemptyset(sigset_t *set); Cette fonction permet d'initialiser et vider un ensemble de signal. signal.h
SIGFILLSET int sigfillset(sigset_t *set); Cette fonction permet d'initialiser et remplir un ensemble de signal. signal.h
SIGHOLD int sighold(int sig); Cette fonction permet d'ajouter un signal à masque de signal. signal.h
SIGIGNORE int sigignore(int sig); Cette fonction permet de fixer la disposition d'un signal. signal.h
SIGINTERRUPT int siginterrupt(int sig, int flag); Cette fonction permet aux signaux d'interrompre les fonctions. signal.h
SIGISMEMBER int sigismember(const sigset_t *set, int signo); Cette fonction permet de vérifier si un signal est dans l'ensemble de signal. signal.h
SIGLONGJMP void siglongjmp(sigjmp_buf env, int val); Cette fonction permet d'effectuer la restauration de la pile dans un saut non local et d'envoyer un signal. setjmp.h
SIGNAL void (*signal(int signal,void (*shandle)(int)))(int) Cette fonction effectue un traitement de signal. signal.h
SIGPAUSE int sigpause(int sig); Cette fonction permet d'enlever un signal du masque de signal et suspend l'exécution de processus léger. signal.h
SIGPENDING int sigpending(sigset_t *set); Cette fonction permet d'examiner le signal bloquant ou en attente. signal.h
SIGPROCMASK int sigprocmask(int how, const sigset_t *set, sigset_t *oset); Cette fonction permet de modifier et/ou d'examiner le masque de signal du processus appelant. signal.h
SIGQUEUE int sigqueue(pid_t pid, int signo, const union sigval value); Cette fonction permet de mettre en file d'attente un signal dans un processus. signal.h
SIGRELSE int sigrelse(int sig); Cette fonction permet d'enlever un signal d'un masque de signal. signal.h
SIGSET void (*sigset(int sig, void (*disp)(int)))(int); Cette fonction permet de modifier la disposition du signal. signal.h
SIGSETJMP int sigsetjmp(sigjmp_buf env, int savemask); Cette fonction permet de fixer un point de saut pour un saut non local. setjmp.h
SIGSTACK int sigstack(struct sigstack *ss, struct sigstack *oss); Cette fonction permet de fixer et/ou demander un signal de contexte de pile alternatif. signal.h
SIGSUSPEND int sigsuspend(const sigset_t *sigmask); Cette fonction permet d'installer un masque de signal et de suspendre le processus jusqu'à ce que le signal se produise. signal.h
SIGTIMEDWAIT int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout); Cette fonction permet d'attendre après le signal de file d'attente le nombre de temps spécifié. signal.h
SIGWAIT int sigwait(const sigset_t *set, int *sig); Cette fonction permet d'attendre après le signal de file d'attente. signal.h
SIGWAITINFO int sigwaitinfo(const sigset_t *set, siginfo_t *info); Cette fonction permet d'attendre après les informations du signal de file d'attente. signal.h
SIN double sin(double x) Cette fonction trigonométrique retourne le «Sinus». math.h
SINH double sinh(double a) Cette fonction trigonométrique retourne le «Sinus» hyperbolique. math.h
SLEEP unsigned int sleep(unsigned int seconds); Cette fonction permet de faire passer en mode pause le processus courant. unistd.h
SNPRINTF int snprintf(char *s, size_t n, const char *format, ...); Cette fonction permet d'effectuer l'écriture de texte selon un certain format dans une chaîne de caractères. stdio.h
SPRINTF int sprintf(char *tampon,const char *texte,...) Cette fonction effectue l'écriture de texte selon un certain format à partir d'un tampon. stdio.h
SQRT double sqrt(double a) Cette fonction retourne la racine carré du nombre «a». math.h
SRAND void srand(unsigned s) Cette procédure initialise le générateur de nombre aléatoire. stdlib.h
SRAND48 void srand48(long int seedval); Cette procédure initialise le générateur de nombre aléatoire en 48 bits. stdlib.h
SRANDOM void srandom(unsigned int seed); Cette fonction permet d'initialiser le générateur de nombre aléatoire. stdlib.h
SSCANF int sscanf(const char *tampon,const *format,...) Cette fonction permet la lecture de texte suivant un certain format à partir d'un tampon. stdio.h
STAT int stat(const char *path, struct stat *buf); Cette fonction permet de demander tous les propriétés d'un fichier. sys/stat.h
STATVFS int statvfs(const char *path, struct statvfs *buf); Cette fonction permet de demander les informations du système de fichiers en utilisant un nom de fichier. sys/statvfs.h
STEP int step(const char *string, const char *expbuf); Cette fonction permet d'indiquer une palette de correspondance pour une expression régulière. regexp.h
STRCASECMP int strcasecmp(const char *s1, const char *s2); Cette fonction permet de comparer deux chaînes de caractères sans effectuer de différence entre les majuscules ou les minuscules. strings.h
STRCAT char *strcat(char *s1,char *s2) Cette fonction permet la concaténation de chaînes. string.h
STRCHR char *strchr(char *str,int c) Cette fonction effectue la recherche du premier caractère «c» dans la chaîne de caractères «str». string.h
STRCMP int strcmp(const char *str1,const char *str2) Cette fonction effectue la comparaison de deux chaînes de caractères. string.h
STRCPY char *strcpy(const char *str1,const char *str2) Cette fonction effectue la copie d'une chaîne de caractères dans une autre chaîne de caractères. string.h
STRCSPN char *strcspn(const char *str1,const char *str2) Cette fonction effectue la recherche de la sous-chaine «str1» ne contenant aucun des caractères contenu dans «str2». string.h
STRERROR char *strerror(int noerr) Cette fonction pointe sur le message d'erreur correspondant à «noerr». string.h
STRFMON ssize_t strfmon(char *s, size_t maxsize, const char *format, ...); Cette fonction permet de convertir une valeur monétaire en une chaîne de caractères. monetary.h
STRFTIME size_t strftime(char *s, size_t maxsize, const char *format, const struct tm *timptr); Cette fonction permet d'effectuer la conversion des informations de date et de l'heure en une chaîne de caractères. time.h
STRLEN size_t strlen(const char *str) Cette fonction permet de calculer la longueur de la chaîne de caractères. string.h
STRNCASECMP int strncasecmp(const char *s1, const char *s2, size_t n); Cette fonction permet de comparer deux débuts de chaînes de caractères sans effectuer de différence entre les majuscules ou les minuscules. strings.h
STRNCAT char *strncat(const char *str1,const char *str2,size_t n) Cette fonction permet d'ajouter les «n» premiers caractères de la chaîne de caractères «str1» à la chaîne de caractères «str2». string.h
STRNCMP int strncmp(const char *str1,const char *str2,size_t n) Cette fonction permet de comparer les «n» premiers caractères de la chaîne de caractères «str1» à la chaîne de caractères «str2». string.h
STRNCPY char *strncpy(const char *str1,const char *str2,size_t n) Cette fonction permet de copier les «n» premiers caractères de la chaîne de caractères «str1» à la chaîne de caractères «str2». string.h
STRPBRK char *strpbrk(const char *source,const char *accept) Cette fonction effectue la recherche dans la chaîne de caractères «source» de la chaîne de caractères «accept». string.h
STRPTIME char *strptime(const char *buf, const char *format, struct tm *tm); Cette fonction permet d'effectuer la conversion de la date et de l'heure à partir d'un pointeur dans un tampon vers un structure spécifié. time.h
STRRCHR char *strrchr(const char *str,int c) Cette fonction effectue la recherche du dernière caractère «c» dans la chaîne de caractères «str». string.h
STRSPN int strspn(const char *str1,const char *str2) Cette fonction effectue le calcul de la longueur de la chaine de caractères «str1» dans lequel sont compris des caractères de la chaine de caractères «str2». string.h
STRSTR char *strstr(const char *str1,const char *str2) Cette fonction de recherche la chaine de caractères «str2» dans la chaine de caractères «str1». string.h
STRTOD double strtod(const char *str1,char **fin) Cette fonction permet de convertir la chaine de caractères en nombre de type «double». stdlib.h
STRTOK char *strtok(const char *str1,const char *str2) Cette fonction permet de couper la chaine de caractères «str1» en symbole élémentaire (Token) en les séparant par les caractères de la chaine de caractères «str2». string.h
STRTOK_R char *strtok_r(char *s, const char *sep, char **lasts); Cette fonction permet de couper la chaîne de caractères spécifié en symbole élémentaires (Token) en les séparant par les caractères de la deuxième chaîne de caractères spécifié avec un ou plusieurs chaîne de caractères de séparation spécifié. string.h
STRTOL long strtol(const char *str1,char **fin,int base) Cette fonction permet de convertir la chaine de caractères en nombre de type «long». stdlib.h
STRTOUL unsigned long strtoul(const char *str1,char **fin,int base) Cette fonction permet de convertir la chaine de caractères en nombre de type non-signée «long». stdlib.h
STRXFRM size_t strxfrm(char *s1, const char *s2, size_t n); Cette fonction permet d'effectuer la transformation d'une chaîne de caractères. string.h
SWAB void swab(const void *src, void *dest, ssize_t nbytes); Cette fonction permet d'inverser des paires d'octets dans un tampon. unistd.h
SWAPCONTEXT int swapcontext(ucontext_t *oucp, const ucontext_t *ucp); Cette fonction permet d'enregistrer le contexte actuel dans la structure de contexte spécifié et définit le contexte de la structure de contexte spécifié. ucontext.h
SWPRINTF int swprintf(wchar_t *s, size_t n, const wchar_t *format, ...); Cette fonction permet d'effectuer l'écriture de texte selon un certain format à partir d'un tampon en utilisant une chaîne de caractères Unicode. wchar.h
SYMLINK int symlink(const char *path1, const char *path2); Cette fonction permet la création d'un fichier ayant un lien symbolique avec un fichier déjà existant. unistd.h
SYNC void sync(void); Cette fonction permet de planifier une mise à jour du système de fichiers. unistd.h
SYSCONF long int sysconf(int name); Cette fonction permet de demander la valeur d'une clef de configuration du système. unistd.h
SYSLOG void syslog(int priority, const char *message, ... /* arguments */); Cette fonction permet d'écrire un message dans le journal de bord. syslog.h
SYSTEM int system(const char *commande) Cette fonction permet de lancée un commande dans le système d'exploitation. stdlib.h
TAN double tan(double x) Cette fonction trigonométrique retourne la «tangente». math.h
TANH double tanh(double a) Cette fonction trigonométrique retourne la «tangente» hyperbolique. math.h
TCDRAIN int tcdrain(int fildes); Cette fonction permet de rechercher dans la sortie de la file d'attente d'un flux d'argument. termios.h
TCFLOW int tcflow(int fildes, int action); Cette fonction permet d'effectuer un contrôle de réserve d'un flux d'argument. termios.h
TCFLUSH int tcflush(int fildes, int queue_selector); Cette fonction permet de vider les tampons d'entrée/sortie d'un flux d'argument. termios.h
TCGETATTR int tcgetattr(int fildes, struct termios *termios_p); Cette fonction permet de demander les paramètres associé avec le terminal. termios.h
TCGETPGRP pid_t tcgetpgrp(int fildes); Cette fonction permet de demander l'identificateur de groupe de processus d'un flux d'argument. unistd.h
TCGETSID pid_t tcgetsid(int fildes); Cette fonction permet de demander l'identificateur de grouper de processus de la session pour le terminal spécifié. termios.h
TCSENDBREAK int tcsendbreak(int fildes, int duration); Cette fonction permet d'envoyer un signal d'arrêt à un flux d'argument. termios.h
TCSETATTR int tcsetattr(int fildes, int optional_actions, const struct termios *termios_p); Cette fonction permet de fixer les paramètres du terminal. termios.h
TCSETPGRP int tcsetpgrp(int fildes, pid_t pgid_id); Cette fonction permet de fixer l'identificateur de groupe de processus d'un groupe de processus de premier plan d'un contrôle de terminal. unistd.h
TDELETE void *tdelete(const void *key, void **rootp, int (*compar)(const void *, const void *)); Cette fonction permet de supprimer un noeud d'un arbre de recherche binaire. search.h
TELLDIR long int telldir(DIR *dirp); Cette fonction permet de demander la position de lecture dans le flux de données de répertoire précédemment ouvert par «opendir». dirent.h
TEMPNAM char *tempnam(const char *dir, const char *pfx); Cette fonction permet de créer un nom de fichier temporaire. stdio.h
TFIND void *tfind(const void *key, void *const *rootp, int (*compar)(const void *, const void *)); Cette fonction permet d'effectuer une recherche dans un arbre de recherche binaire. search.h
TIME time_t time(time_t *ptrheure) Cette fonction permet d'effectuer le calcul de l'heure courante en secondes. time.h
TIMER_CREATE int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid); Cette fonction permet de créer une minuterie par processus. time.h
TIMER_DELETE int timer_delete(timer_t timerid); Cette fonction permet de supprimer une minuterie par processus. time.h
TIMER_GETTIME int timer_gettime(timer_t timerid, struct itimerspec *value); Cette fonction permet d'entreposer une quantité de temps jusqu'à ce que la minuterie spécifié expire et jusqu'à la valeur de rechargement de la minuterie dans l'espace spécifié. time.h
TIMER_GETOVERRUN int timer_getoverrun(timer_t timerid); Cette fonction permet de retourner le nombre de dépassement d'expiration du temporisateur pour le temporisateur spécifié. time.h
TIMER_SETTIME int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue); Cette fonction permet de fixer l'heure jusqu'à la prochaine expiration de la minuterie spécifié du membre spécifié et arme la minuterie si le membre spécifié est différent de 0. time.h
TIMES clock_t times(struct tms *buffer); Cette fonction permet de demander le temps réel écoulés depuis un point du passé (comme le démarrage du système), de l'utilisateur et du système pour un processus parent et enfant. sys/times.h
TMPFILE FILE *tmpfile(void) Cette fonction permet d'effectuer la création d'un fichier temporaire. stdio.h
TMPNAM char *tmpname(char *nom) Cette fonction permet de choisir le nom de création d'un fichier temporaire. stdio.h
TOASCII int toascii(int c); Cette fonction effectue la conversion d'un entier en format ASCII. ctype.h
TOLOWER int tolower(int caractere) Cette fonction effectue la conversion d'un caractère en lettre minuscule. ctype.h
TOUPPER int toupper(int caractere) Cette fonction effectue la conversion d'un caractère en lettre majuscule. ctype.h
TOWCTRANS wint_t towctrans(wint_t wc, wctrans_t desc); Cette fonction permet de faire correspondre le caractère Unicode spécifié en utilisant la cartographie spécifié. wctype.h
TOWLOWER wint_t towlower(wint_t wc); Cette fonction permet d'effectuer la conversion d'un caractère Unicode en lettre minuscule. wchar.h
TOWUPPER wint_t towupper(wint_t wc); Cette fonction permet d'effectuer la conversion d'un caractère Unicode en lettre majuscule. wchar.h
TRUNCATE int truncate(const char *path, off_t length); Cette fonction permet de tronquer un fichier à la longueur spécifié. unistd.h
TSEARCH void *tsearch(const void *key, void **rootp, int (*compar)(const void *, const void *)); Cette fonction permet de construire l'arbre afin d'y accéder. search.h
TTYNAME char *ttyname(int fildes); Cette fonction permet de demander le nom du terminal spécifié. unistd.h
TTYNAME_R int ttyname_r(int fildes, char *name, size_t namesize); Cette fonction permet de demander le nom du terminal spécifié et copie le résultat dans le tampon spécifié. unistd.h
TTYSLOT int ttyslot(void); Cette fonction permet de rechercher la fente de l'utilisateur courante dans la base de données de compte. stdlib.h
TWALK void twalk(const void *root, void (*action)(const void *, VISIT, int )); Cette fonction permet de parcourir l'arbre de recherche binaire. search.h
TZSET void tzset(void); Cette fonction permet de fixer le fuseau horaire de base d'une variable d'environnement TZ. time.h
UALARM useconds_t ualarm(useconds_t useconds, useconds_t interval); Cette fonction permet de fixer l'intervalle de la minuterie. unistd.h
ULIMIT long int ulimit(int cmd, ...); Cette fonction permet de demander ou de fixer la limite d'utilisation d'un processus. ulimit.h
UMASK mode_t umask(mode_t cmask); Cette fonction permet de changer le masque Unix d'un processus en cours. sys/stat.h
UNAME int uname(struct utsname *name); Cette fonction permet de demander le nom du système d'exploitation courant. sys/utsname.h
UNGETC int ungetc(int c,FILE *ptrfichier) Cette fonction effectue la réécriture d'un caractère dans un fichier ayant été lu. stdio.h
UNGETWC wint_t ungetwc(wint_t wc, FILE *stream); Cette fonction permet d'effectuer la réécriture d'un caractère Unicode dans un fichier ayant été lu. wchar.h
UNLINK int unlink(const char *path); Cette fonction permet de supprimer un ou plusieurs fichiers. unistd.h
UNLOCKPT int unlockpt(int fildes); Cette fonction permet de déverrouiller une paire de pseudo-terminal maître/esclave. stdlib.h
USLEEP int usleep(useconds_t useconds); Cette fonction permet d'attendre un nombre de milliseconde spécifié et reprendre l'exécution du programme aussitôt après. unistd.h
UTIME int utime(const char *path, const struct utimbuf *times); Cette fonction permet de modifier le temps de fichiers et répertoires. utime.h
UTIMES int utimes(const char *path, const struct timeval times[2]); Cette fonction permet de fixer l'accès aux fichiers et les temps de modification. sys/time.h
VALLOC void *valloc(size_t size); Cette fonction permet d'allouer de la mémoire avec un alignement de page. stdlib.h
VA_ARG type va_arg(va_list ptrargument,type) Cette fonction donne l'argument (le paramètre) suivant de la fonction. stdarg.h
VA_END void va_end(va_list ptrargument) Cette procédure fixe le pointeur d'argument à la toute fin. stdarg.h
VA_START void va_start(va_list ptrargument) Cette procédure fixe le pointeur d'argument au tout début. stdarg.h
VFORK pid_t vfork(void); Cette fonction permet d'effectuer la création d'un processus en partageant sa mémoire virtuel. unistd.h
VFPRINTF int vfprintf(FILE *ptrfichier,const char *texte,va_list ptrargument) Cette fonction effectue l'écriture de texte selon un certain format à l'aide de paramètre virtuel. stdio.h
VFWPRINTF int vfwprintf(FILE *stream, const wchar_t *format, va_list arg); Cette fonction permet d'effectuer l'écriture de texte selon un certain format à l'aide de paramètre virtuel avec une chaîne de caractères Unicode. wchar.h
VPRINTF int vprintf(const char *texte,va_list ptrargument) Cette fonction effectue l'écriture de texte selon un certain format à l'aide de paramètre virtuel sur la console. stdio.h
VSNPRINTF int vsnprintf(char *s, size_t n, const char *format, va_list ap); Cette fonction permet de formater les données sous le contrôle de la chaîne de caractères de format spécifié et d'entreposer le résultat dans le tampon spécifié. stdio.h
VSPRINTF int vsprintf(char *tampon,const char *texte,va_list ptrargument) Cette fonction effectue l'écriture de texte selon un certain format à l'aide de paramètre virtuel à partir d'un tampon. stdio.h
VSWPRINTF int vswprintf(wchar_t *s, size_t n, const wchar_t *format, va_list arg); Cette fonction permet d'effectuer l'écriture de texte Unicode selon un certain format à l'aide de paramètre virtuel à partir d'un tampon. wchar.h
VWPRINTF int vwprintf(const wchar_t *format, va_list arg); Cette fonction permet d'effectuer l'écriture de texte Unicode selon un certain format à l'aide de paramètre virtuel sur la console. wchar.h
WADD_WCH int wadd_wch(WINDOW *win, const cchar_t *wch) Cette fonction permet d'ajouter un caractère à une fenêtre spécifique. curses.h
WADD_WCHNSTR int wadd_wchnstr(WINDOW *win, const cchar_t *wchstr, int n) Cette fonction permet d'ajouter une chaine de caractères d'une longueur spécifié à une fenêtre spécifique. curses.h
WADD_WCHSTR int wadd_wchstr(WINDOW *win, const cchar_t *wchstr) Cette fonction permet d'ajouter une chaine de caractères à une fenêtre spécifique. curses.h
WAIT pid_t wait(int *stat_loc); Cette fonction permet de mettre en attente jusqu'à la fin d'un processus fils. sys/wait.h
WAIT3 pid_t wait3(int *stat_loc, int options, struct rusage *resource_usage); Cette fonction permet d'attendre après un changement d'état de processus enfant. sys/wait.h
WAITID int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options); Cette fonction permet de mettre en attente jusqu'à qu'un processus fils change d'état. sys/wait.h
WAITPID pid_t waitpid(pid_t pid, int *stat_loc, int options); Cette fonction permet de mettre en attente jusqu'à la fin d'un processus fils ayant un numéro de processus spécifié (PID). sys/wait.h
WCRTOMB size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); Cette fonction permet de demander le nombre d'octets nécessaires pour entrer l'état de décalage initial. wchar.h
WCSCAT wchar_t *wcscat(wchar_t *ws1, const wchar_t *ws2); Cette fonction permet la concaténation de chaînes de caractères Unicode. wchar.h
WCSCHR wchar_t *wcschr(const wchar_t *ws, wchar_t wc); Cette fonction permet d'effectuer la recherche du premier caractère spécifié dans la chaîne de caractères Unicode spécifié. wchar.h
WCSCMP int wcscmp(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet d'effectuer la comparaison de deux chaînes de caractères Unicode. wchar.h
WCSCOLL int wcscoll(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet de comparer deux chaînes de caractères Unicode en format locale sans effectuer de différence entre les majuscules ou les minuscules. wchar.h
WCSCPY wchar_t *wcscpy(wchar_t *ws1, const wchar_t *ws2); Cette fonction permet d'effectuer la copie d'une chaîne de caractères Unicode dans une autre chaîne de caractères Unicode. wchar.h
WCSCSPN size_t wcscspn(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet d'effectuer la recherche de la sous-chaîne de caractères Unicode spécifié ne contenant aucun des caractères contenu dans l'autre chaîne de caractères Unicode. wchar.h
WCSFTIME size_t wcsftime(wchar_t *wcs, size_t maxsize, const wchar_t *format, const struct tm *timptr); Cette fonction permet d'effectuer la conversion des informations de date et de l'heure en une chaîne de caractères Unicode. wchar.h
WCSLEN size_t wcslen(const wchar_t *ws); Cette fonction permet de calculer la longueur de la chaîne de caractères Unicode. wchar.h
WCSNCAT wchar_t *wcsncat(wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet d'ajouter les premiers caractères spécifié de la chaîne de caractères Unicode spécifié à l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSNCMP int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet de comparer les premiers caractères spécifié de la chaîne de caractères Unicode spécifié à l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSNCPY wchar_t *wcsncpy(wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet de copier les premiers caractères de la chaîne de caractères Unicode spécifié dans l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSPBRK wchar_t *wcspbrk(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet d'effectuer la recherche dans la chaîne de caractères Unicode spécifié de l'autre chaîne de caractères Unicode. wchar.h
WCSRCHR wchar_t *wcsrchr(const wchar_t *ws, wchar_t wc); Cette fonction permet d'effectuer la recherche du dernière caractère Unicode spécifié dans la chaîne de caractères Unicode spécifié. wchar.h
WCSRTOMBS size_t wcsrtombs(char *dst, const wchar_t **src, size_t len, mbstate_t *ps); Cette fonction permet d'effectuer la conversion d'une séquence de caractères Unicode d'un tableau indirectement pointer vers la source spécifié en une séquence de caractères multi-octets correspondant au commencement de l'état de décalage spécifié et n'étant pas un pointeur nul, et ensuite, il l'entrepose dans le tableau spécifié. wchar.h
WCSSPN size_t wcsspn(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet d'effectuer le calcul de la longueur de la chaîne de caractères Unicode spécifié dans lequel sont compris des caractères dans l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSSTR wchar_t *wcsstr(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet de rechercher la chaîne de caractères Unicode spécifié dans l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSTOD double wcstod(const wchar_t *nptr, wchar_t **endptr); Cette fonction permet de convertir la chaîne de caractères Unicode en nombre de type de données réel de double précision. wchar.h
WCSTOK wchar_t *wcstok(wchar_t *ws1, const wchar_t *ws2, wchar_t **ptr); Cette fonction permet de couper la chaîne de caractères Unicode spécifié en symbole élémentaire (Token) en les séparant par les caractères dans l'autre chaîne de caractères Unicode spécifié. wchar.h
WCSTOL long int wcstol(const wchar_t *nptr, wchar_t **endptr, int base); Cette fonction permet de convertir la chaîne de caractères Unicode en nombre de type «long». wchar.h
WCSTOMBS size_t wcstombs(char *s, const wchar_t *pwcs, size_t n); Cette fonction permet d'effectuer la conversion d'une chaîne de caractères étendue en une chaîne de caractères de format multi-octets. stdlib.h
WCSTOUL unsigned long int wcstoul(const wchar_t *nptr, wchar_t **endptr, int base); Cette fonction permet de convertir la chaîne de caractères Unicode en nombre de type non-signée «long». wchar.h
WCSWCS wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2); Cette fonction permet de rechercher une sous-chaîne de caractères Unicode. wchar.h
WCSWIDTH int wcswidth(const wchar_t *pwcs, size_t n); Cette fonction permet de demander le nombre de positions de colonne d'une chaîne de caractères Unicode. wchar.h
WCSXFRM size_t wcsxfrm(wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet d'effectuer la transformation d'une chaîne de caractères Unicode. wchar.h
WCTOB int wctob(wint_t c); Cette fonction permet de demander si la valeur spécifié correspond à un membre du jeu de caractères étendu dont la représentation multi-octets est un octet unique lorsqu'il est dans l'état de décalage initial. wchar.h
WCTOMB int wctomb(char *s, wchar_t wchar); Cette fonction permet d'effectuer la conversion d'un caractère étendue en un caractère de format multi-octets. stdlib.h
WCTRANS wctrans_t wctrans(const char *charclass); Cette fonction permet de construire une valeur avec le type wctrans_t lequel décrit une cartographie entre des caractères Unicode spécifié. wctype.h
WCTYPE wctype_t wctype(const char *property); Cette fonction permet de construire une valeur avec le type wctype_t lequel décrit une classe de caractères Unicode spécifié. wchar.h
WCWIDTH int wcwidth(wchar_t wc); Cette fonction permet de demander le nombre de positions de colonne d'un code de caractère Unicode. wchar.h
WMEMCHR wchar_t *wmemchr(const wchar_t *ws, wchar_t wc, size_t n); Cette fonction permet de rechercher un caractère Unicode dans le tampon dans le nombre d'octets spécifiés. wchar.h
WMEMCMP int wmemcmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet de rechercher un tampon de recherche Unicode dans le tampon de données Unicode avec le nombre d'octets spécifiés. wchar.h
WMEMCPY wchar_t *wmemcpy(wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet de copier un tampon source Unicode dans un tampon de destination Unicode avec le nombre d'octets spécifiés. wchar.h
WMEMMOVE wchar_t *wmemmove(wchar_t *ws1, const wchar_t *ws2, size_t n); Cette fonction permet de copier un tampon source Unicode dans un tampon de destination Unicode avec le nombre d'octets spécifiés. wchar.h
WMEMSET wchar_t *wmemset(wchar_t *ws, wchar_t wc, size_t n); Cette fonction permet de remplir avec un caractère Unicode un tampon avec le nombre d'octets spécifiés. wchar.h
WORDEXP int wordexp(const char *words, wordexp_t *pwordexp, int flags); Cette fonction permet d'exécuter des extensions de mots XCU. wordexp.h
WORDFREE void wordfree(wordexp_t *pwordexp); Cette fonction permet de libérer une extensions de mots XCU. wordexp.h
WPRINTF int wprintf(const wchar_t *format, ...); Cette fonction permet d'effectuer l'écriture de texte selon un certain format sur la console avec une chaîne de caractères Unicode. wchar.h
WRITE ssize_t write(int fildes, const void *buf, size_t nbyte); Cette fonction permet d'effectuer des écritures dans un fichier précédemment ouvert. unistd.h
WRITEV ssize_t writev(int fildes, const struct iovec *iov, int iovcnt); Cette fonction permet d'effectuer l'écriture d'un vecteur dans un fichier. sys/uio.h
WSCANF int wscanf(const wchar_t *format, ... ); Cette fonction permet la lecture de texte suivant un certain format dans une console standard en utilisant une chaîne de caractères Unicode. wchar.h
Y0 double y0(double x); Cette fonction permet de retourner la fonction Bessel de y0. math.h
Y1 double y1(double x); Cette fonction permet de retourner la fonction Bessel de y1. math.h
YN double yn(int n, double x); Cette fonction permet de retourner la fonction Bessel de yn. math.h
_EXIT void _exit(int status); Cette fonction permet de mettre fin à l'exécution d'un programme. unistd.h
_LONGJMP void _longjmp(jmp_buf env, int val); Cette fonction permet d'effectuer la restauration de la pile dans un saut non local. setjmp.h
_SETJMP int _setjmp(jmp_buf env); Cette fonction permet d'effectuer la sauvegarde de la pile. setjmp.h
_TOLOWER int _tolower(int c); Cette fonction permet d'effectuer la conversion d'un caractère en lettre minuscule. ctype.h
_TOUPPER int _toupper(int c); Cette fonction permet d'effectuer la conversion d'un caractère en lettre majuscule. ctype.h


Dernière mise à jour : Dimanche, le 28 juin 2015