-
Notifications
You must be signed in to change notification settings - Fork 16
/
stdlib.txt
168 lines (155 loc) · 10.7 KB
/
stdlib.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
STDLIB.H
div_t #Structure renvoyée par div() contenant deux INT_VAR,
#respectivement STKTDIV_T.quot (le résultat entier de la
#division) et STKTDIV_T.rem (le reste)
ldiv_t #Même chose, mais avec des LONG_INT, et ldiv()
EXIT_SUCCESS #Voir la doc principale
EXIT_FAILURE #Même chose
RAND_MAX #Nombre maximal généré par rand() (en général INT_MAX)
MB_CUR_MAX #Nombre maximal d'octets dans un caractère multi-octet
#en fonction de la locale courante (peut être 1, comme
#en anglais)
exit(INT_VAL) #Comme return INT_VAL, sauf que cela quitte non
#seulement la fonction courante, mais tout le programme
#avec (ferme et flush les streams ouverts)
abort(void) #Stoppe le programme avec un SIGABRT (fermeture
#anormale, unsucessful termination pour l'environment
#host), et ferme et flush les streams ouverts.
------> Ne retourne rien
atexit(FONC_VAR) #Une fois que le main() s'achève, FONC_VAR sera appelé,
#et ce, avant tout FONC_VAR précédemment déclaré avec
#atexit(). Le main() doit s'achever normalement, avec un
#exit() ou un return par exemple, mais pas avec un
#abort() par exemple. FONC_VAR ne doit pas se terminer
#par un exit() ou un longjmp()
#atexit(*FONC_ADR) est donc aussi possible
----| Renvoie 0 si succès, != 0 sinon
system(STR) #Exécute STR avec le system host (diffère en fonction de
#l'implémentation, mais en général, c'est /bin/sh -c)
#SIGCHLD sera bloqué, et SIGINT et SIGQUIT ignorés.
#Pour savoir si un interpréteur est disponible, faire
#avant un system(NULL) qui retourne != 0 si c'est le cas
#et 0 sinon.
----| Return exit value de STR si succès, -1 si erreur.
rand(void) ----# Renvoie un INT_VAL généré pseudo-aléatoirement, en
| fonction d'une seed (1 par défaut, donc renvoie
| toujours la même liste de nombres aléatoires si la
| seed n'est pas modifiée). Les rand() qui suivent
| suivent une liste pseudo-aléatoire, toujours identique
| pour une même seed.
| Le nombre maximal généré est RAND_MAX
srand(INT_VAL) #La seed de rand() devient INT_VAL
#On peut par exemple utiliser time(NULL)
abs(INT_VAL) ----# Renvoie la valeur absolue d'INT_VAL
labs(LONG_INT_VAL) ----# Renvoie la valeur absolue de LONG_INT_VAL
div(INT_VAL1, ----# Renvoie une DIV_T_VAR résultante de l'opération
INT_VAL2) | INT_VAL1 / INT_VAL2
ldiv(LONG_INT_VAL1, ----# Renvoie une LDIV_T_VAR résultante de l'opération
LONG_INT_VAL2) | LONG_INT_VAL1 / LONG_INT_VAL2
getenv(STR) ----# Soit STR une CLEF, renvoie sa CLEF_VAL sous forme de
| STR, ou NULL si CLEF n'a pas été trouvé. Il s'agit de
| la référence directe à la STR de l'environment : la
| modifier modifie l'environment. Préférer setenv() pour
| la modification d'environment variables.
atof(STR) #Equivaut à strtod(STR, (char **)NULL). A ne pas
#utiliser, car il est impossible de savoir si 0 est
#retourné, si cela est parceque STR contenait 0 ou si
#c'est parce qu'elle était invalide, et ne détecte pas
#les erreurs.
#Préférer strtod()
atol(STR) #Même chose, équivaut à strtol(STR, (char **)NULL, 10)
atoi(STR) #Même chose, équivaut à strtol(STR, (char **)NULL, 10),
#mais en renvoyant un INT_VAL.
strtod(STR, STR_ADR) #Tronque tous les caractères de STR ressemblant à un
#nombre depuis le début de STR jusqu'au premier
#caractère ne semblant pas faire partie d'un nombre, et
#affecte cela à la STR pointée par STR_ADR (ne modifie
#pas STR), sauf si STR_ADR_ADR est NULL
----| Renvoie STR, interprété comme un nombre, sous forme
| de DOUBLE_LIT (arrête l'interprétation au premier
| caractère ne semblant pas faire partie d'un nombre).
| Renvoie 0 si STR n'est pas valide.
| Ainsi, si :
| - STR == *STR_ADR, STR n'était pas un nombre valide
| - STR == 0, et STR == *STR_ADR, STR n'était pas
| valide
| - STR == 0, et STR != *STR_ADR, STR était valide et
| représentait 0.
| - Si STR_ADR != '\0' mais que *STR_ADR == '\0', toute
| STR a été valide
| En cas d'overflow, +/-HUGE_VAL est renvoyé, et ERANGE
| est placé dans errno. En cas d'underflow, 0 est
| renvoyé, et ERANGE est placé dans errno.
strtol(STR, STR_ADR, #Comme strtod(), mais pour les LONG_INT. De plus, STR
INT_VAL) #est lu comme étant de base INT_VAL, et converti en base
#décimale.
----| Même chose, mais en cas d'overflow, ne renvoie pas
| +/- HUGE_VAL, mais LONG_MIN ou LONG_MAX
strtoul(STR, STR_ADR, #Comme strtol(), mais pour les UNSIGNED_LONG_INT
INT_VAL) ----| Même chose, mais en cas d'overflow, renvoie ULONG_MIN
| ou ULONG_MAX
malloc(SIZE_T_VAL) #Alloue un espace de SIZE_T_VAL octets dans le heap.
#L'espace alloué doit être libéré avec free() quand il
#n'est plus libéré, et avant que le pointeur renvoyé
#n'existe plus, sinon cela crée une fuite de mémoire
#(memory leak). Attention donc à ne pas réassigner
#le pointeur auquel sera affectée cette adresse.
#Ainsi, il ne faudra pas faire ADR = ..., mais :
# - strncpy(ADR, ... pour une STR
# - memcpy(ADR, ... pour une autre ADR
#SIZE_T_VAL contient souvent sizeof(TYPE) * TOUINT_VAL,
#où TYPE est le type de l'array qui utilisera cet
#espace, et TOUINT_VAL le nombre d'éléments maximal sans
#rencontrer de problèmes.
----| Renvoie un VOID_ADR pointant vers le début de cet
| espace. Renvoie NULL si aucun espace n'est
| disponible. Doit toujours checké donc ensuite :
| - if ( ( ADR = malloc(SIZE_T_VAL)) == NULL )
| pour gérer ce problème éventuel.
| Le VOID_ADR est en général transtypé, par exemple :
| - int* INT_ADR = malloc(TOUINT_VAL * sizeof(int))
calloc(SIZE_T_VAL1, #Equivaut à malloc(SIZE_T_VAL1 * SIZE_T_VAL2), mais
SIZE_T_VAL2) #initialise en plus l'espace alloué avec des 0
realloc(ADR, # Comme malloc, mais :
SIZE_T_VAL) ----| 1) utilise l'espace déjà alloué à ADR pour le
| rétrécir/élargir et retourne donc un VOID_ADR du
| même ADR.
| 2) si l'espace contigu à l'espace déjà alloué à ADR
| n'est pas suffisant, libère cet espace et en crée
| un nouveau, qu'il renvoie sous la forme d'un
| VOID_ADR également.
| 3) Renvoie NULL sinon. Pour éviter que NULL soit
| renvoyer vers l'ADR originel, et qu'il devienne
| ainsi impossible de free(ADR), ne pas faire :
| - TYPE* ADR = realloc(ADR, SIZE_T_VAL)
| Mais :
| - if ( ( ADR2 = realloc(ADR1, SIZE_T_VAL) )
| == NULL ) {
| ...
| } else {
| ADR1 = ADR2;
| ADR2 = NULL;
| }
free(ADR) #Libère l'espace dynamique alloué à ADR.
#Si ADR est NULL, ne fait rien
#Cependant faire un free sur un ADR déjà freed (double
#free) conduit à un segfault, il faut donc initialiser
#ADR à NULL après free(ADR) :
# - if ( ADR ) {
# free(ADR);
# ADR = NULL;
# } else {
# ...
# }
#if ( ADR ) sert à ne pas assigner NULL à un ADR déjà
#NULL
#On ne peut en général pas affecter de valeur à un ADR
#freed, mais ici c'est ok, car c'est juste après, et ça
#permet d'éviter les double free
mblen(STR, SIZE_T_VAL)--# Inspecte les SIZE_T_VAL premiers octets de STR, et dès
| qu'une séquence de 1 ou plusieurs octets représentant
| un seul caractère est trouvé, renvoie le nombre
| d'octets de cette séquence.
| Sinon, renvoie -1, ou 0 si STR est '\0'