Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
Ɏɭɧɤɰɢɹ fwrite ɡɚɩɢɫɵɜɚɟɬ nobj ɨɛɴɟɤɬɨɜ ɪɚɡɦɟɪɚ size ɢɡ ɦɚɫɫɢɜɚ
ptr ɜ ɩɨɬɨɤ stream; ɨɧɚ ɜɨɡɜɪɚɳɚɟɬ ɱɢɫɥɨ ɡɚɩɢɫɚɧɧɵɯ ɨɛɴɟɤɬɨɜ, ɤɨɬɨɪɨɟ ɜ
ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɛɭɞɟɬ ɦɟɧɶɲɟ nobj. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
_t fwrite(const void *ptr, size_t size, size_t nobj, FILE
size
*stream)
Ɏɭɧɤɰɢɹ fseek ɭɫɬɚɧɚɜɥɢɜɚɟɬ ɮɚɣɥɨɜɵɣ ɭɤɚɡɚɬɟɥɶ ɜ ɡɚɞɚɧɧɭɸ ɩɨɡɢɰɢɸ
ɜ ɩɨɬɨɤɟ stream; ɩɨɫɥɟɞɭɸɳɟɟ ɱɬɟɧɢɟ ɢɥɢ ɡɚɩɢɫɶ ɛɭɞɟɬ ɩɪɨɢɡɜɨɞɢɬɶɫɹ ɫ ɷɬɨɣ
ɩɨɡɢɰɢɢ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
int fseek(FILE *stream, long offset, int origin)
Ⱦɥɹ ɞɜɨɢɱɧɨɝɨ ɮɚɣɥɚ ɩɨɡɢɰɢɹ ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɫɨ ɫɦɟɳɟɧɢɟɦ offset
ɫɢɦɜɨɥɨɜ ɨɬɧɨɫɢɬɟɥɶɧɨ ɬɨɱɤɢ ɨɬɫɱɟɬɚ, ɡɚɞɚɜɚɟɦɨɣ ɩɚɪɚɦɟɬɪɨɦ origin: ɧɚɱɚɥɚ, ɟɫɥɢ origin ɪɚɜɟɧ SEEK_SET, ɬɟɤɭɳɟɣ ɩɨɡɢɰɢɢ, ɟɫɥɢ origin ɪɚɜɟɧ
SEEK_CUR; ɢ ɤɨɧɰɚ ɮɚɣɥɚ,
ɟɫɥɢ origin ɪɚɜɟɧ SEEK_END. Ⱦɥɹ ɬɟɤɫɬɨɜɨɝɨ
ɮɚɣɥɚ ɩɚɪɚɦɟɬɪ offset ɞɨɥɠɟɧ ɛɵɬɶ ɧɭɥɟɦ ɢɥɢ ɡɧɚɱɟɧɢɟɦ, ɩɨɥɭɱɟɧɧɵɦ ɫ
ɩɨɦɨɳɶɸ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ ftell (ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ, origin ɞɨɥɠɟɧ ɛɵɬɶ ɪɚɜɟɧ SEEK_SET). Ɏɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɱɢɫɥɨ ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ.
Ɏɭɧɤɰɢɹ ftell ɜɨɡɜɪɚɳɚɟɬ ɬɟɤɭɳɭɸ ɩɨɡɢɰɢɸ ɭɤɚɡɚɬɟɥɹ ɜ ɩɨɬɨɤɟ
stream, ɢɥɢ -1L, ɟɫɥɢ ɨɛɧɚɪɭɠɟɧɚ ɨɲɢɛɤɚ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
long ftell(FILE *stream)
int fgetpos(FILE *stream, fpos_t *ptr)
Ɏɭɧɤɰɢɹ fgetpos ɡɚɩɢɫɵɜɚɟɬ
ɬɟɤɭɳɭɸ ɩɨɡɢɰɢɸ ɜ ɩɨɬɨɤɟ stream ɜ
*ptr ɞɥɹ ɩɨɫɥɟɞɭɸɳɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɟɟ ɜ ɮɭɧɤɰɢɢ fsetpos. Ɍɢɩ fpos_t
ɩɨɡɜɨɥɹɟɬ ɯɪɚɧɢɬɶ ɡɧɚɱɟɧɢɹ ɬɚɤɨɝɨ ɪɨɞɚ. ȼ ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ
ɧɟɧɭɥɟɜɨɟ ɱɢɫɥɨ.
int fsetpos(FILE *stream, const fpost *ptr)
Ɏɭɧɤɰɢɹ fsetpos ɭɫɬɚɧɚɜɥɢɜɚɟɬ ɩɨɡɢɰɢɸ ɜ ɩɨɬɨɤɟ stream, ɱɢɬɚɹ
ɟɟ ɢɡ ɚɪɝɭɦɟɧɬɚ *ptr, ɤɭɞɚ ɨɧɚ ɛɵɥɚ ɡɚɩɢɫɚɧɚ ɪɚɧɟɟ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ
f getpos. ȼ ɫɥɭɱɚɟ ɨɲɢɛɤɢ
ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɱɢɫɥɨ.
Ɇɧɨɝɢɟ ɮɭɧɤɰɢɢ ɛɢɛɥɢɨɬɟɤɢ ɜ ɫɥɭɱɚɟ ɨɛɧɚɪɭɠɟɧɢɹ ɨɲɢɛɤɢ ɢɥɢ ɞɨɫɬɢɠɟɧɢɹ ɤɨɧɰɚ ɮɚɣɥɚ ɭɫɬɚɧɚɜɥɢɜɚɸɬ ɢɧɞɢɤɚɬɨɪɵ ɫɨɫɬɨɹɧɢɹ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɢɡɦɟɧɹɬɶ ɢ ɩɪɨɜɟɪɹɬɶ.
Ʉɪɨɦɟ ɬɨɝɨ, ɰɟɥɨɱɢɫɥɟɧɧɨɟ ɜɵɪɚɠɟɧɢɟ errno (ɨɛɴɹɜɥɟɧɧɨɟ ɜ
<errno.h>) ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ ɧɨɦɟɪ ɨɲɢɛɤɢ, ɤɨɬɨɪɵɣ ɞɚɟɬ ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ
ɢɧɮɨɪɦɚɰɢɸ ɨ ɩɨɫɥɟɞɧɟɣ ɢɡ ɫɥɭɱɢɜɲɢɯɫɹ ɨɲɢɛɨɤ.
Ɏɭɧɤɰɢɹ clearerr ɫɛɪɚɫɵɜɚɟɬ ɢɧɞɢɤɚɬɨɪɵ ɤɨɧɰɚ
ɮɚɣɥɚ ɢ ɨɲɢɛɨɤ ɩɨɬɨ-
ɤɚ stream:
void clearerr(FILE *stream)
Ɏɭɧɤɰɢɹ feof ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɟɫɥɢ ɞɥɹ ɩɨɬɨɤɚ stream
ɭɫɬɚɧɨɜɥɟɧ (ɜɤɥɸɱɟɧ) ɢɧɞɢɤɚɬɨɪ ɤɨɧɰɚ ɮɚɣɥɚ:
int feof(FILE *stream)
Ɏɭɧɤɰɢɹ ferror ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɟɫɥɢ ɞɥɹ ɩɨɬɨɤɚ stream
ɭɫɬɚɧɨɜɥɟɧ (ɜɤɥɸɱɟɧ) ɢɧɞɢɤɚɬɨɪ ɨɲɢɛɤɢ.
int ferror(FILE *stream)
171
Ⱥ.2. Ȼɢɛɥɢɨɬɟɤɚ ɮɭɧɤɰɢɣ ɚɧɚɥɢɡɚ ɫɢɦɜɨɥɨɜ ctype
ȼ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ <ctype.h> ɨɛɴɹɜɥɟɧɵ ɩɪɨɬɨɬɢɩɵ ɮɭɧɤɰɢɣ,
ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɯ ɞɥɹ ɚɧɚɥɢɡɚ ɫɢɦɜɨɥɨɜ. Ⱥɪɝɭɦɟɧɬ ɤɚɠɞɨɣ ɢɡ ɧɢɯ ɢɦɟɟɬ ɬɢɩ
int ɢ ɞɨɥɠɟɧ ɩɪɟɞɫɬɚɜɥɹɬɶ ɫɨɛɨɣ ɥɢɛɨ EOF, ɥɢɛɨ unsigned char, ɩɪɢɜɟɞɟɧɧɵɣ ɤ int, ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ ɬɨɠɟ ɢɦɟɟɬ ɬɢɩ int. Ɏɭɧɤɰɢɢ ɜɨɡɜɪɚɳɚɸɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ (ɢɫɬɢɧɚ), ɟɫɥɢ ɚɪɝɭɦɟɧɬ ɫ ɭɞɨɜɥɟɬɜɨɪɹɟɬ
ɧɟɤɨɬɨɪɨɦɭ ɭɫɥɨɜɢɸ ɢɥɢ ɩɪɢɧɚɞɥɟɠɢɬ ɤ ɭɤɚɡɚɧɧɨɦɭ ɤɥɚɫɫɭ ɫɢɦɜɨɥɨɜ, ɢ ɧɭɥɶ (ɥɨɠɶ) ɜ
ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ:
isalnum(c) – isalpha (ɫ) ɢɥɢ isdigit (ɫ) ɟɫɬɶ ɢɫɬɢɧɚ;
isalpha(c) – isupper (ɫ) ɢɥɢ islower (ɫ) ɟɫɬɶ ɢɫɬɢɧɚ;
iscntrl(c) – ɭɩɪɚɜɥɹɸɳɢɣ ɫɢɦɜɨɥ;
isdigit(c) – ɞɟɫɹɬɢɱɧɚɹ ɰɢɮɪɚ;
isgraph(c) –
ɨɬɨɛɪɚɠɚɟɦɵɣ ɫɢɦɜɨɥ, ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɩɪɨɛɟɥɚ;
islower(c) – ɛɭɤɜɚ ɜ ɧɢɠɧɟɦ ɪɟɝɢɫɬɪɟ;
isprint(c) – ɨɬɨɛɪɚɠɚɟɦɵɣ ɫɢɦɜɨɥ, ɜ ɬɨɦ ɱɢɫɥɟ ɩɪɨɛɟɥ;
ispunct(c) – ɨɬɨɛɪɚɠɚɟɦɵɣ ɫɢɦɜɨɥ, ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɩɪɨɛɟɥɚ, ɛɭɤɜɵ
ɢɥɢ ɰɢɮɪɵ;
isspace(c) – ɩɪɨɛɟɥ, ɩɪɨɝɨɧ ɫɬɪɚɧɢɰɵ, ɤɨɧɟɰ ɫɬɪɨɤɢ, ɜɨɡɜɪɚɬ ɤɚɪɟɬɤɢ,
ɬɚɛɭɥɹɰɢɹ, ɜɟɪɬɢɤɚɥɶɧɚɹ ɬɚɛɭɥɹɰɢɹ;
isupper(c) – ɛɭɤɜɚ ɜ ɜɟɪɯɧɟɦ ɪɟɝɢɫɬɪɟ;
isxdigit(c) – ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɚɹ ɰɢɮɪɚ.
ȼ ɫɟɦɢɛɢɬɨɜɨɦ ɫɢɦɜɨɥɶɧɨɦ ɧɚɛɨɪɟ ASCII ɨɬɨɛɪɚɠɚɟɦɵɟ ɫɢɦɜɨɥɵ
ɡɚɧɢɦɚ-
ɸɬ ɞɢɚɩɚɡɨɧ ɨɬ 0x2 0 (' ') ɞɨ 0ɯ7ȿ ('–'); ɭɩɪɚɜɥɹɸɳɢɟ ɫɢɦɜɨɥɵ – ɨɬ 0 (NUL)
ɞɨ 0x1F (US), a ɬɚɤɠɟ 0x7F (DEL).
ɉɨɦɢɦɨ ɩɟɪɟɱɢɫɥɟɧɧɵɯ, ɟɫɬɶ ɟɳɟ ɞɜɟ ɮɭɧɤɰɢɢ, ɢɡɦɟɧɹɸɳɢɟ ɪɟɝɢɫɬɪ ɛɭɤɜ:
int tolower(int ɫ) – ɩɟɪɟɜɨɞɢɬ ɫ ɜ ɧɢɠɧɢɣ ɪɟɝɢɫɬɪ;
int toupper(int ɫ) – ɩɟɪɟɜɨɞɢɬ ɫ ɜ ɜɟɪɯɧɢɣ ɪɟɝɢɫɬɪ.
Ⱥ.3. Ȼɢɛɥɢɨɬɟɤɚ ɮɭɧɤɰɢɣ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɤɚɦɢ
string
Ɏɭɧɤɰɢɢ ɞɥɹ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɤɚɦɢ ɨɩɢɫɚɧɵ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ
string.h. ɂɦɟɸɬɫɹ ɞɜɟ ɝɪɭɩɩɵ ɮɭɧɤɰɢɣ ɞɥɹ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɤɚɦɢ, ɨɩɪɟɞɟɥɟɧɧɵɯ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ <string.h> – ɢɦɟɧɚ ɮɭɧɤɰɢɣ ɩɟɪɜɨɣ ɝɪɭɩɩɵ
ɧɚɱɢɧɚɸɬɫɹ ɫ ɩɪɟɮɢɤɫɚ str, ɚ ɜɬɨɪɨɣ – ɫ ɩɪɟɮɢɤɫɚ mem. Ɂɚ ɢɫɤɥɸɱɟɧɢɟɦ
memmove, ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɮɭɧɤɰɢɣ ɧɟ ɨɩɪɟɞɟɥɟɧ, ɟɫɥɢ ɜɵɩɨɥɧɹɟɬɫɹ ɤɨɩɢɪɨɜɚɧɢɟ ɨɛɴɟɤɬɨɜ, ɩɟɪɟɤɪɵɜɚɸɳɢɯɫɹ
ɜ ɩɚɦɹɬɢ. Ɏɭɧɤɰɢɢ ɫɪɚɜɧɟɧɢɹ ɜɨɫɩɪɢɧɢɦɚ-
ɸɬ ɚɪɝɭɦɟɧɬɵ ɤɚɤ ɦɚɫɫɢɜɵ ɷɥɟɦɟɧɬɨɜ ɬɢɩɚ unsigned char.
ȼ ɬɚɛɥɢɰɟ Ⱥ.1 ɩɟɪɟɦɟɧɧɵɟ s ɢ t ɩɪɢɧɚɞɥɟɠɚɬ ɤ ɬɢɩɭ char *, cs ɢ ct –
ɤ ɬɢɩɭ const char *, n – ɤ ɬɢɩɭ size_t, ɚ ɫ ɹɜɥɹɟɬɫɹ ɱɢɫɥɨɦ ɬɢɩɚ int,
ɩɪɢɜɟɞɟɧɧɵɦ ɤ ɬɢɩɭ char.
172
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ Ⱥ.1
Ɏɭɧɤɰɢɢ ɞɥɹ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɤɚɦɢ
Ɏɭɧɤɰɢɹ ɉɨɹɫɧɟɧɢɟ
char *strcpy(s,ct)
Ʉɨɩɢɪɭɟɬ ɫɬɪɨɤɭ ct ɜ ɫɬɪɨɤɭ s, ɜɤɥɸɱɚɹ
ɜɨɡɜɪɚɳɚɟɬ s
'\0';
Ʉɨɩɢɪɭɟɬ ɧɟ ɛɨɥɟɟ n ɫɢɦɜɨɥɨɜ ɫɬɪɨɤɢ ct ɜ s;
char *strncpy(s,ct, n)
ɜɨɡɜɪɚɳɚɟɬ s. Ⱦɨɩɨɥɧɹɟɬ ɪɟɡɭɥɶɬɚɬ ɫɢɦɜɨɥɚɦɢ '\0',
ɟɫɥɢ ɜ ct ɦɟɧɶɲɟ n ɫɢɦɜɨɥɨɜ
char *strcat(s,ct) ɉɪɢɫɨɟɞɢɧɹɟɬ ct ɜ ɤɨɧɟɰ ɫɬɪɨɤɢ s; ɜɨɡɜɪɚɳɚɟɬ s
char *strncat(s,ct,n)
int strcmp(cs,ct)
ɉɪɢɫɨɟɞɢɧɹɟɬ ɧɟ ɛɨɥɟɟ n ɫɢɦɜɨɥɨɜ ɫɬɪɨɤɢ ct ɤ s,
ɡɚɜɟɪɲɚɹ s ɫɢɦɜɨɥɨɦ
'\0'; ɜɨɡɜɪɚɳɚɟɬ s
ɋɪɚɜɧɢɜɚɟɬ ɫɬɪɨɤɢ cs ɢ ct; ɜɨɡɜɪɚɳɚɟɬ < 0, ɟɫɥɢ
cs<ct; 0, ɟɫɥɢ cs==ct; ɢ >0, ɟɫɥɢ cs>ct
ɋɪɚɜɧɢɜɚɟɬ ɧɟ ɛɨɥɟɟ n ɫɢɦɜɨɥɨɜ ɫɬɪɨɤ cs ɢ ct;
int strncmp(cs,ct,n)
ɜɨɡɜɪɚɳɚɟɬ < 0, ɟɫɥɢ cs<ct; 0, ɟɫɥɢ cs==ct; ɢ > 0,
ɟɫɥɢ cs>ct
char *strchr(cs,c)
char *strrchr(cs,c)
size_t strspn(cs,ct)
size_t strcspn(cs,ct)
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɜɨɟ ɜɯɨɠɞɟɧɢɟ ɫ ɜ cs
ɢɥɢ null ɩɪɢ ɨɬɫɭɬɫɬɜɢɢ ɬɚɤɨɜɨɝɨ
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɨɫɥɟɞɧɟɟ ɜɯɨɠɞɟɧɢɟ ɫ
ɜ cs ɢɥɢ null ɩɪɢ ɨɬɫɭɬɫɬɜɢɢ ɬɚɤɨɜɨɝɨ
ȼɨɡɜɪɚɳɚɟɬ ɞɥɢɧɭ ɧɚɱɚɥɶɧɨɝɨ ɭɱɚɫɬɤɚ cs,
ɫɨɫɬɨɹɳɟɝɨ ɢɡ ɫɢɦɜɨɥɨɜ, ɜɯɨɞɹɳɢɯ ɜ ɫɬɪɨɤɭ ct
ȼɨɡɜɪɚɳɚɟɬ ɞɥɢɧɭ ɧɚɱɚɥɶɧɨɝɨ ɭɱɚɫɬɤɚ cs,
ɫɨɫɬɨɹɳɟɝɨ ɢɡ ɫɢɦɜɨɥɨɜ, ɧɟ ɜɯɨɞɹɳɢɯ ɜ ct
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɜɵɣ ɫɢɦɜɨɥ ɜ ɫɬɪɨɤɟ
char *strpbrk(cs,ct)
cs, ɤɨɬɨɪɵɣ ɫɨɜɩɚɞɚɟɬ ɫ ɨɞɧɢɦ ɢɡ ɫɢɦɜɨɥɨɜ,
ɜɯɨɞɹɳɢɯ ɜ ɫɬɪɨɤɭ ct, ɢɥɢ null, ɟɫɥɢ ɬɚɤɨɝɨ
ɧɟ ɨɤɚɡɚɥɨɫɶ
char *strstr(cs,ct)
char *strerror (n)
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɜɨɟ ɜɯɨɠɞɟɧɢɟ ɫɬɪɨɤɢ
ct ɜ ɫɬɪɨɤɭ cs ɢɥɢ null, ɟɫɥɢ ɬɚɤɨɝɨ ɧɟ ɨɤɚɡɚɥɨɫɶ
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɨɤɭ, ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ
ɧɨɦɟɪɭ ɨɲɢɛɤɢ ɬ (ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ)
size_t strlen(cs) ȼɨɡɜɪɚɳɚɟɬ ɞɥɢɧɭ cs
char *strtok(s,ct)
ɂɳɟɬ ɜ ɫɬɪɨɤɟ s ɥɟɤɫɟɦɵ, ɨɝɪɚɧɢɱɟɧɧɵɟ ɫɢɦɜɨɥɚɦɢ
ɢɡ ɫɬɪɨɤɢ ct; ɛɨɥɟɟ ɩɨɞɪɨɛɧɨɟ ɨɩɢɫɚɧɢɟ ɫɦ. ɧɢɠɟ
ɉɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɜɵɡɨɜɨɜ strtok(s, ct) ɪɚɡɛɢɜɚɟɬ ɫɬɪɨɤɭ s ɧɚ
ɥɟɤɫɟɦɵ, ɨɝɪɚɧɢɱɢɬɟɥɟɦ ɤɨɬɨɪɵɯ ɫɥɭɠɢɬ ɥɸɛɨɣ ɫɢɦɜɨɥ ɢɡ ɫɬɪɨɤɢ ct. ɉɪɢ ɩɟɪɜɨɦ ɜɵɡɨɜɟ ɜ ɷɬɨɣ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ ɭɤɚɡɚɬɟɥɶ s ɧɟ ɪɚɜɟɧ NULL. Ɏɭɧɤɰɢɹ
173
ɧɚɯɨɞɢɬ ɜ ɫɬɪɨɤɟ s ɩɟɪɜɭɸ ɥɟɤɫɟɦɭ, ɫɨɫɬɨɹɳɭɸ ɢɡ ɫɢɦɜɨɥɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɜɯɨɞɹɬ ɜ ct; ɨɧɚ ɡɚɤɚɧɱɢɜɚɟɬ ɪɚɛɨɬɭ ɬɟɦ, ɱɬɨ ɡɚɩɢɫɵɜɚɟɬ ɩɨɜɟɪɯ ɫɥɟɞɭɸɳɟɝɨ ɫɢɦɜɨɥɚ s ɫɢɦɜɨɥ '\0' ɢ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɥɟɤɫɟɦɭ. Ʉɚɠɞɵɣ ɩɨɫɥɟɞɭɸɳɢɣ
ɜɵɡɨɜ, ɜ ɤɨɬɨɪɨɦ ɭɤɚɡɚɬɟɥɶ s ɪɚɜɟɧ NULL, ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɥɟɞɭɸɳɭɸ ɬɚɤɭɸ ɥɟɤɫɟɦɭ, ɤɨɬɨɪɭɸ ɮɭɧɤɰɢɹ ɛɭɞɟɬ
ɢɫɤɚɬɶ ɫɪɚɡɭ ɩɨɫɥɟ ɤɨɧɰɚ ɩɪɟɞɵɞɭɳɟɣ. Ɏɭɧɤɰɢɹ strtok ɜɨɡɜɪɚɳɚɟɬ NULL, ɟɫɥɢ ɞɚɥɟɟ ɧɟ ɨɛɧɚɪɭɠɢɜɚɟɬ ɧɢɤɚɤɢɯ ɥɟɤɫɟɦ. ɉɚɪɚɦɟɬɪ ct ɨɬ ɜɵɡɨɜɚ ɤ ɜɵɡɨɜɭ ɦɨɠɟɬ ɦɟɧɹɬɶɫɹ.
Ɏɭɧɤɰɢɢ ɫɟɦɟɣɫɬɜɚ mem. . . ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɦɚɧɢɩɭɥɢɪɨɜɚɧɢɹ
ɨɛɴɟɤɬɚɦɢ ɤɚɤ ɦɚɫɫɢɜɚɦɢ ɫɢɦɜɨɥɨɜ; ɨɧɢ ɨɛɪɚɡɭɸɬ ɢɧɬɟɪɮɟɣɫ ɤ ɛɵɫɬɪɨɞɟɣɫɬɜɭɸɳɢɦ ɫɢɫɬɟɦɧɵɦ ɮɭɧɤɰɢɹɦ. ȼ ɩɪɢɜɟɞɟɧɧɨɣ ɧɢɠɟ ɬɚɛɥ. Ⱥ.2 ɩɚɪɚɦɟɬɪɵ s
ɢ t ɨɬɧɨɫɹɬɫɹ
ɤ ɬɢɩɭ void *; cs ɢ ct – ɤ ɬɢɩɭ const void *; n– ɤ ɬɢɩɭ
size_t; ɚ ɩɚɪɚɦɟɬɪ ɫ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɱɢɫɥɨ ɬɢɩɚ int, ɩɪɢɜɟɞɟɧɧɨɟ ɤ ɬɢɩɭ char.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ Ⱥ.2
Ɏɭɧɤɰɢɢ ɝɪɭɩɩɵ mem
Ɏɭɧɤɰɢɹ ɉɨɹɫɧɟɧɢɟ
void *memcpy(s, ct, n) Ʉɨɩɢɪɭɟɬ n ɫɢɦɜɨɥɨɜ ɢɡ ct ɜ s, ɜɨɡɜɪɚɳɚɟɬ s
Ⱦɟɥɚɟɬ ɬɨ ɠɟ ɫɚɦɨɟ, ɱɬɨ ɢ memcpy, ɧɨ ɪɚɛɨɬɚɟɬ
void *memmove(s, ct, n)
ɤɨɪɪɟɤɬɧɨ ɬɚɤɠɟ ɜ ɫɥɭɱɚɟ ɩɟɪɟɤɪɵɜɚɸɳɢɯɫɹ ɜ
ɩɚɦɹɬɢ ɨɛɴɟɤɬɨɜ
ɋɪɚɜɧɢɜɚɟɬ ɩɟɪɜɵɟ n ɫɢɦɜɨɥɨɜ cs ɢ ct;
int memcmp(cs/ct/n)
ɜɨɡɜɪɚɳɚɟɬ ɬɟ ɠɟ ɪɟɡɭɥɶɬɚɬɵ, ɱɬɨ ɢ ɮɭɧɤɰɢɹ
strcmp
ȼɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɜɨɟ ɜɯɨɠɞɟɧɢɟ
void *memchr(cs, ɫ, n)
ɫɢɦɜɨɥɚ ɫ ɜ cs ɢɥɢ null, ɟɫɥɢ ɨɧ ɨɬɫɭɬɫɬɜɭɟɬ
ɫɪɟɞɢ ɩɟɪɜɵɯ n ɫɢɦɜɨɥɨɜ
void *memset(s, ɫ, n)
ɉɨɦɟɳɚɟɬ ɫɢɦɜɨɥ ɫ ɜ ɩɟɪɜɵɟ n ɩɨɡɢɰɢɣ ɦɚɫɫɢɜɚ s ɢ ɜɨɡɜɪɚɳɚɟɬ s
ȼ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ <math.h> ɨɛɴɹɜɥɹɸɬɫɹ ɦɚɬɟɦɚɬɢɱɟɫɤɢɟ ɮɭɧɤɰɢɢ
ɢ ɦɚɤɪɨɫɵ. Ɇɚɤɪɨɫɵ EDOM ɢ ERANGE (ɨɩɪɟɞɟɥɟɧɧɵɟ ɜ <errno.h>) – ɷɬɨ ɨɬɥɢɱɧɵɟ ɨɬ ɧɭɥɹ ɰɟɥɨɱɢɫɥɟɧɧɵɟ ɤɨɧɫɬɚɧɬɵ, ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɥɹ ɢɧɞɢɤɚɰɢɢ
ɨɲɢɛɤɢ ɨɛɥɚɫɬɢ ɨɩɪɟɞɟɥɟɧɢɹ ɢ ɨɲɢɛɤɢ ɜɵɯɨɞɚ ɡɚ ɞɢɚɩɚɡɨɧ; HUGE_VAL ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɩɨɥɨɠɢɬɟɥɶɧɨɟ ɱɢɫɥɨ ɬɢɩɚ double. Ɉɲɢɛɤɚ ɨɛɥɚɫɬɢ ɨɩɪɟɞɟɥɟ-
Ⱥ.4. Ȼɢɛɥɢɨɬɟɤɚ ɦɚɬɟɦɚɬɢɱɟɫɤɢɯ ɮɭɧɤɰɢɣ math
ɧɢɹ ɜɨɡɧɢɤɚɟɬ, ɟɫɥɢ ɚɪɝɭɦɟɧɬ ɜɵɯɨɞɢɬ ɡɚ ɩɪɟɞɟɥɵ
ɱɢɫɥɨɜɨɣ ɨɛɥɚɫɬɢ, ɜ ɤɨɬɨɪɨɣ
ɨɩɪɟɞɟɥɟɧɚ ɮɭɧɤɰɢɹ. ɉɪɢ ɜɨɡɧɢɤɧɨɜɟɧɢɢ ɬɚɤɨɣ ɨɲɢɛɤɢ ɩɟɪɟɦɟɧɧɨɣ errno
ɩɪɢɫɜɚɢɜɚɟɬɫɹ ɡɧɚɱɟɧɢɟ EDOM; ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ.
Ɉɲɢɛɤɚ ɜɵɯɨɞɚ ɡɚ ɞɢɚɩɚɡɨɧ ɜɨɡɧɢɤɚɟɬ ɬɨɝɞɚ, ɤɨɝɞɚ ɪɟɡɭɥɶɬɚɬ ɮɭɧɤɰɢɢ ɧɟɥɶɡɹ
ɩɪɟɞɫɬɚɜɢɬɶ ɜ ɜɢɞɟ double. ȼ ɫɥɭɱɚɟ ɩɟɪɟɩɨɥɧɟɧɢɹ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ
174
HUGE_VAL ɫ ɩɪɚɜɢɥɶɧɵɦ ɡɧɚɤɨɦ, ɢ ɜ errno ɩɨɦɟɳɚɟɬɫɹ ɡɧɚɱɟɧɢɟ ERANGE.
ȿɫɥɢ ɩɪɨɢɫɯɨɞɢɬ ɩɨɬɟɪɹ ɡɧɚɱɢɦɨɫɬɢ (ɪɟɡɭɥɶɬɚɬ ɨɤɚɡɵɜɚɟɬɫɹ ɦɟɧɶɲɟ, ɱɟɦ ɦɨɠɧɨ ɩɪɟɞɫɬɚɜɢɬɶ ɞɚɧɧɵɦ ɬɢɩɨɦ), ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɧɭɥɶ; ɩɨɥɭɱɚɟɬ ɥɢ ɜ ɷɬɨɦ
ɫɥɭɱɚɟ ɩɟɪɟɦɟɧɧɚɹ errno ɡɧɚɱɟɧɢɟ ERANGE – ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ.
ȼ ɬɚɛɥɢɰɟ Ⱥ.3 ɩɚɪɚɦɟɬɪɵ ɯ ɢ ɭ ɢɦɟɸɬ ɬɢɩ double, n – ɬɢɩ int, ɢ ɜɫɟ
ɮɭɧɤɰɢɢ ɜɨɡɜɪɚɳɚɸɬ ɡɧɚɱɟɧɢɹ ɬɢɩɚ double. ɍɝɥɵ ɞɥɹ ɬɪɢɝɨɧɨɦɟɬɪɢɱɟɫɤɢɯ
ɮɭɧɤɰɢɣ ɡɚɞɚɸɬɫɹ ɜ ɪɚɞɢɚɧɚɯ.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ Ⱥ.3
Ɇɚɬɟɦɚɬɢɱɟɫɤɢɟ ɮɭɧɤɰɢɢ ɋɢ
Ɏɭɧɤɰɢɹ ɉɨɹɫɧɟɧɢɟ
sin(x) ɋɢɧɭɫ x
cos(x) Ʉɨɫɢɧɭɫ x
tan(x) Ɍɚɧɝɟɧɫ ɯ
asin(x)
acos(x)
atan(x)
atan2(y, x)
Ⱥɪɤɫɢɧɭɫ ɯ ɜ ɞɢɚɩɚɡɨɧɟ [–S/2, S/2], ɯ ɟ [–1,1]
Ⱥɪɤɤɨɫɢɧɭɫ ɯ ɜ ɞɢɚɩɚɡɨɧɟ [0, S], ɯ ɟ [–1,1]
Ⱥɪɤɬɚɧɝɟɧɫ ɯ ɜ ɞɢɚɩɚɡɨɧɟ [–S/2, S/2]
Ⱥɪɤɬɚɧɝɟɧɫ ɭ/ɯ ɜ ɞɢɚɩɚɡɨɧɟ [–S,S]
sinh(x) Ƚɢɩɟɪɛɨɥɢɱɟɫɤɢɣ ɫɢɧɭɫ ɯ
cosh(x) Ƚɢɩɟɪɛɨɥɢɱɟɫɤɢɣ ɤɨɫɢɧɭɫ ɯ
tanh(x) Ƚɢɩɟɪɛɨɥɢɱɟɫɤɢɣ ɬɚɧɝɟɧɫ ɯ
exp(x) ɗɤɫɩɨɧɟɧɰɢɚɥɶɧɚɹ ɮɭɧɤɰɢɹ ɟx
log(x) ɇɚɬɭɪɚɥɶɧɵɣ ɥɨɝɚɪɢɮɦ ln(x), x > 0
log10(x) Ⱦɟɫɹɬɢɱɧɵɣ ɥɨɝɚɪɢɮɦ lg(x), x > 0
ɭ
. ȼɨɡɧɢɤɚɟɬ ɨɲɢɛɤɚ ɨɛɥɚɫɬɢ
pow(x, y)
ȼɨɡɜɟɞɟɧɢɟ ɜ ɫɬɟɩɟɧɶ ɯ
ɨɩɪɟɞɟɥɟɧɢɹ, ɟɫɥɢ ɯ = 0 ɢ ɭ < 0 ɢɥɢ ɟɫɥɢ ɯ < 0 ɢ ɭ – ɧɟ
ɰɟɥɨɟ ɱɢɫɥɨ
sqrt(x) Ʉɜɚɞɪɚɬɧɵɣ ɤɨɪɟɧɶ ɯ, ɯ > 0
ceil(x)
floor(x)
ɇɚɢɦɟɧɶɲɟɟ ɰɟɥɨɟ ɱɢɫɥɨ ɜ ɮɨɪɦɚɬɟ double, ɧɨ ɧɟ
ɦɟɧɶɲɟɟ ɯ
ɇɚɢɛɨɥɶɲɟɟ ɰɟɥɨɟ ɱɢɫɥɨ ɜ ɮɨɪɦɚɬɟ double, ɧɟ ɩɪɟɜɨɫɯɨɞɹɳɟɟ ɯ
fabs(x) Ⱥɛɫɨɥɸɬɧɨɟ ɡɧɚɱɟɧɢɟ | ɯ |
ldexp(x, n) Ɋɚɫɫɱɢɬɵɜɚɟɬ ɯā2n
Ɋɚɡɛɢɜɚɟɬ ɯ ɧɚ ɞɜɚ ɫɨɦɧɨɠɢɬɟɥɹ, ɩɟɪɜɵɣ ɢɡ ɤɨɬɨɪɵɯ –
ɧɨɪɦɚɥɢɡɨɜɚɧɧɚɹ ɞɪɨɛɶ ɜ ɢɧɬɟɪɜɚɥɟ [1/2,1), ɜɨɡɜɪɚɳɚ-
frexp(x, int*exp)
ɟɦɚɹ ɮɭɧɤɰɢɟɣ, ɚ ɜɬɨɪɨɣ – ɫɬɟɩɟɧɶ ɞɜɨɣɤɢ; ɷɬɨ ɱɢɫɥɨ
ɩɨɦɟɳɚɟɬɫɹ ɜ *ɟɯɪ. ȿɫɥɢ ɯ ɪɚɜɟɧ ɧɭɥɸ, ɬɨ ɨɛɟ ɱɚɫɬɢ
ɪɟɡɭɥɶɬɚɬɚ ɪɚɜɧɵ ɧɭɥɸ
175
Ɏɭɧɤɰɢɹ ɉɨɹɫɧɟɧɢɟ
modf(x, double*ip)
fmod(x, y)
Ɉ ɤ ɨ ɧ ɱ ɚ ɧ ɢ ɟ ɬ ɚ ɛ ɥ ɢ ɰ ɵ Ⱥ.3
Ɋɚɡɛɢɜɚɟɬ ɯ ɧɚ ɰɟɥɭɸ ɢ ɞɪɨɛɧɭɸ ɱɚɫɬɢ, ɨɛɟ ɫ ɬɟɦ ɠɟ
ɡɧɚɤɨɦ, ɱɬɨ ɢ ɯ. ɐɟɥɚɹ ɱɚɫɬɶ ɩɨɦɟɳɚɟɬɫɹ ɜ *ip,
ɚ ɞɪɨɛɧɚɹ ɱɚɫɬɶ ɜɨɡɜɪɚɳɚɟɬɫɹ ɢɡ ɮɭɧɤɰɢɢ
Ɉɫɬɚɬɨɤ ɨɬ ɞɟɥɟɧɢɹ ɯ ɧɚ ɭ ɜ ɜɢɞɟ ɜɟɳɟɫɬɜɟɧɧɨɝɨ ɱɢɫɥɚ.
Ɂɧɚɤ ɪɟɡɭɥɶɬɚɬɚ ɫɨɜɩɚɞɚɟɬ ɫɨ ɡɧɚɤɨɦ ɯ. ȿɫɥɢ ɭ ɪɚɜɟɧ
ɧɭɥɸ, ɪɟɡɭɥɶɬɚɬ ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ ɹɡɵɤɚ
ȼ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ stdlib.h ɨɛɴɹɜɥɟɧɵ ɮɭɧɤɰɢɢ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ
ɞɥɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɱɢɫɟɥ, ɪɚɫɩɪɟɞɟɥɟɧɢɹ ɩɚɦɹɬɢ ɢ ɞɪɭɝɢɯ ɩɨɞɨɛɧɵɯ ɡɚɞɚɱ.
Ɏɭɧɤɰɢɹ atof ɩɪɟɨɛɪɚɡɭɟɬ ɫɬɪɨɤɭ s ɜ ɱɢɫɥɨ ɬɢɩɚ double:
double atof(const char *s)
Ɏɭɧɤɰɢɹ atoi ɩɪɟɨɛɪɚɡɭɟɬ ɫɬɪɨɤɭ s ɜ ɱɢɫɥɨ ɬɢɩɚ int:
int atoi(const char *s)
Ɏɭɧɤɰɢɹ atol ɩɪɟɨɛɪɚɡɭɟɬ ɫɬɪɨɤɭ s ɜ ɱɢɫɥɨ ɬɢɩɚ long:
long atoi(const char *s)
Ɏɭɧɤɰɢɹ strtod ɩɪɟɨɛɪɚɡɭɟɬ ɩɟɪɜɵɟ ɫɢɦɜɨɥɵ ɫɬɪɨɤɢ s ɜ ɱɢɫɥɨ ɬɢɩɚ
double, ɢɝɧɨɪɢɪɭɹ ɩɭɫɬɨɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɜ ɧɚɱɚɥɟ:
double strtod(const char *s, char **endp)
Ɏɭɧɤɰɢɹ strtod ɩɨɦɟɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟ ɩɪɟɨɛɪɚɡɨɜɚɧɧɭɸ ɱɚɫɬɶ ɜ
*endp (ɟɫɥɢ endp ɧɟ NULL). ɉɪɢ ɩɟɪɟɩɨɥɧɟɧɢɢ ɨɧɚ ɜɨɡɜɪɚɳɚɟɬ HUGE_VAL
ɫ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ ɡɧɚɤɨɦ; ɜ ɫɥɭɱɚɟ ɩɨɬɟɪɢ ɡɧɚɱɢɦɨɫɬɢ (ɪɟɡɭɥɶɬɚɬ ɫɥɢɲɤɨɦ
ɦɚɥ ɞɥɹ ɟɝɨ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɞɚɧɧɵɦ ɬɢɩɨɦ) ɜɨɡɜɪɚɳɚɟɬɫɹ 0; ɜ ɨɛɨɢɯ ɫɥɭɱɚɹɯ ɩɟɪɟɦɟɧɧɚɹ errno ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɪɚɜɧɨɣ ERANGE.
Ⱥ.5. ȼɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɮɭɧɤɰɢɢ
Ɏɭɧɤɰɢɹ strtol ɩɪɟɨɛɪɚɡɭɟɬ
ɩɟɪɜɵɟ ɫɢɦɜɨɥɵ ɫɬɪɨɤɢ s ɜ ɱɢɫɥɨ ɬɢɩɚ
long, ɢɝɧɨɪɢɪɭɹ ɩɭɫɬɨɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɜ ɧɚɱɚɥɟ.
long strtol(const char *s, char **endp, int base)
Ɏɭɧɤɰɢɹ strtol ɩɨɦɟɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟ ɩɪɟɨɛɪɚɡɨɜɚɧɧɭɸ ɱɚɫɬɶ ɜ
*endp (ɟɫɥɢ endp ɧɟ NULL). ȿɫɥɢ base ɧɚɯɨɞɢɬɫɹ ɜ ɞɢɚɩɚɡɨɧɟ ɨɬ 2 ɞɨ 36, ɬɨ
ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɜɵɩɨɥɧɹɟɬɫɹ ɜ ɩɪɟɞɩɨɥɨɠɟɧɢɢ, ɱɬɨ ɱɢɫɥɨ ɜ ɫɬɪɨɤɟ ɡɚɩɢɫɚɧɨ ɩɨ
ɨɫɧɨɜɚɧɢɸ base. ȿɫɥɢ base ɪɚɜɧɨ ɧɭɥɸ, ɬɨ ɨɫɧɨɜɚɧɢɟɦ
ɱɢɫɥɚ ɫɱɢɬɚɟɬɫɹ 8, 10
ɢɥɢ 16. ɑɢɫɥɨ, ɧɚɱɢɧɚɸɳɟɟɫɹ ɫ ɰɢɮɪɵ 0, ɩɪɟɞɩɨɥɚɝɚɟɬɫɹ ɜɨɫɶɦɟɪɢɱɧɵɦ, ɚ ɫ 0ɯ
ɢɥɢ 0ɏ – ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɵɦ. ɐɢɮɪɵ ɨɬ 10 ɞɨ base-1 ɡɚɩɢɫɵɜɚɸɬɫɹ ɩɟɪɜɵɦɢ ɛɭɤɜɚɦɢ ɥɚɬɢɧɫɤɨɝɨ ɚɥɮɚɜɢɬɚ ɜ ɥɸɛɨɦ ɪɟɝɢɫɬɪɟ. ɉɪɢ ɨɫɧɨɜɚɧɢɢ 16 ɜ
ɧɚɱɚɥɟ ɱɢɫɥɚ ɪɚɡɪɟɲɚɟɬɫɹ ɩɨɦɟɳɚɬɶ 0ɯ ɢɥɢ 0ɏ.
ȼ ɫɥɭɱɚɟ ɩɟɪɟɩɨɥɧɟɧɢɹ ɮɭɧɤɰɢɹ strtol ɜɨɡɜɪɚɳɚɟɬ LONG_MAX ɢɥɢ
LONG_MIN ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ
ɡɧɚɤɚ ɪɟɡɭɥɶɬɚɬɚ, ɚ ɜ errno ɩɨɦɟɳɚɟɬɫɹ ɤɨɞ
ɨɲɢɛɤɢ ERANGE.
176
Ɏɭɧɤɰɢɹ strtoul ɪɚɛɨɬɚɟɬ ɬɚɤ ɠɟ, ɤɚɤ ɢ strtol, ɫ ɬɨɣ ɪɚɡɧɢɰɟɣ, ɱɬɨ
ɨɧɚ ɜɨɡɜɪɚɳɚɟɬ ɪɟɡɭɥɶɬɚɬ ɬɢɩɚ uns igned long, ɚ ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ –
ULONG_MAX:
unsigned long strtoul(const char *s, char **endp, int base)
Ɏɭɧɤɰɢɹ rand ɜɨɡɜɪɚɳɚɟɬ ɩɫɟɜɞɨɫɥɭɱɚɣɧɨɟ ɱɢɫɥɨ ɜ ɞɢɚɩɚɡɨɧɟ ɨɬ 0 ɞɨ
RAND_MAX (ɡɧɚɱɟɧɢɟ RAND_MAX ɧɟ ɦɟɧɶɲɟ 32767):
int rand(void)
Ɏɭɧɤɰɢɹ srand ɢɫɩɨɥɶɡɭɟɬ ɩɚɪɚɦɟɬɪ seed ɤɚɤ ɢɧɢɰɢɚɥɢɡɢɪɭɸɳɟɟ ɡɧɚ-
ɱɟɧɢɟ ɞɥɹ ɧɨɜɨɣ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ ɩɫɟɜɞɨɫɥɭɱɚɣɧɵɯ ɱɢɫɟɥ (ɜ ɧɚɱɚɥɟ
ɩɚɪɚ-
ɦɟɬɪ seed ɪɚɜɟɧ 1):
void srand(unsigned int seed)
Ɏɭɧɤɰɢɹ calloc ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɦɟɫɬɨ ɜ ɩɚɦɹɬɢ, ɨɬɜɟɞɟɧɧɨɟ
ɞɥɹ ɦɚɫɫɢɜɚ nobj ɨɛɴɟɤɬɨɜ, ɤɚɠɞɵɣ ɢɡ ɤɨɬɨɪɵɯ ɢɦɟɟɬ ɪɚɡɦɟɪ size ɢɥɢ
NULL, ɟɫɥɢ ɡɚɩɪɨɫ ɧɚ ɩɚɦɹɬɶ ɜɵɩɨɥɧɢɬɶ ɧɟɥɶɡɹ. ȼɵɞɟɥɟɧɧɚɹ ɨɛɥɚɫɬɶ ɩɚɦɹɬɢ
ɨɛɧɭɥɹɟɬɫɹ. ɋɢɧɬɚɤɫɢɫ:
void *calloc(size_t nobj, size_t size)
Ɏɭɧɤɰɢɹ malloc ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɦɟɫɬɨ ɜ ɩɚɦɹɬɢ ɞɥɹ ɨɛɴɟɤɬɚ
ɪɚɡɦɟɪɚ size, ɢɥɢ NULL, ɟɫɥɢ ɡɚɩɪɨɫ
ɧɟɜɵɩɨɥɧɢɦ. ȼɵɞɟɥɟɧɧɚɹ ɨɛɥɚɫɬɶ ɩɚɦɹɬɢ
ɧɟ ɢɧɢɰɢɚɥɢɡɢɪɭɟɬɫɹ. ɋɢɧɬɚɤɫɢɫ:
void *malloc(size t size)
Ɏɭɧɤɰɢɹ realloc ɢɡɦɟɧɹɟɬ ɪɚɡɦɟɪ ɨɛɴɟɤɬɚ, ɧɚ ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɪ, ɧɚ
ɡɚɞɚɧɧɵɣ size:
void *realloc(void *p, size_t size)
Ⱦɥɹ ɭɱɚɫɬɤɚ ɨɛɴɟɤɬɚ, ɞɥɢɧɚ ɤɨɬɨɪɨɝɨ ɪɚɜɧɚ ɦɟɧɶɲɟɦɭ ɪɚɡɦɟɪɭ ɢɡ ɫɬɚɪɨɝɨ ɢ
ɧɨɜɨɝɨ, ɫɨɞɟɪɠɢɦɨɟ ɧɟ ɢɡɦɟɧɹɟɬɫɹ. ȿɫɥɢ ɧɨɜɵɣ ɪɚɡɦɟɪ ɛɨɥɶɲɟ ɫɬɚɪɨɝɨ, ɞɨɩɨɥɧɢɬɟɥɶɧɨɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɧɟ ɢɧɢɰɢɚɥɢɡɢɪɭɟɬɫɹ. Ɏɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ
ɧɚ ɧɨɜɵɣ ɭɱɚɫɬɨɤ
ɩɚɦɹɬɢ ɢɥɢ NULL, ɟɫɥɢ ɡɚɩɪɨɫ ɧɟɜɵɩɨɥɧɢɦ (ɜ ɷɬɨɦ ɫɥɭɱɚɟ *ɪ
ɧɟ ɢɡɦɟɧɹɟɬɫɹ).
void free(void *p)
Ɏɭɧɤɰɢɹ free ɨɫɜɨɛɨɠɞɚɟɬ ɨɛɥɚɫɬɶ ɩɚɦɹɬɢ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɪ; ɨɧɚ ɧɟ
ɞɟɥɚɟɬ ɧɢɱɟɝɨ, ɟɫɥɢ ɪ ɪɚɜɟɧ NULL. ɉɟɪɟɦɟɧɧɚɹ ɪ ɞɨɥɠɧɚ ɭɤɚɡɵɜɚɬɶ ɧɚ ɨɛɥɚɫɬɶ
ɩɚɦɹɬɢ, ɪɚɧɟɟ ɜɵɞɟɥɟɧɧɭɸ ɨɞɧɨɣ ɢɡ ɮɭɧɤɰɢɣ calloc, malloc ɢɥɢ realloc.
Ɏɭɧɤɰɢɹ abort ɜɵɡɵɜɚɟɬ ɚɜɚɪɢɣɧɨɟ ɡɚɜɟɪɲɟɧɢɟ ɩɪɨɝɪɚɦɦɵ:
void abort(void)
Ɏɭɧɤɰɢɹ exit ɜɵɡɵɜɚɟɬ ɧɨɪɦɚɥɶɧɨɟ ɡɚɜɟɪɲɟɧɢɟ ɩɪɨɝɪɚɦɦɵ:
void exit(int status)
ɉɪɢ ɷɬɨɦ ɮɭɧɤɰɢɢ, ɡɚɪɟɝɢɫɬɪɢɪɨɜɚɧɧɵɟ ɫ ɩɨɦɨɳɶɸ atexit, ɜɵɩɨɥɧɹɸɬɫɹ ɜ ɩɨɪɹɞɤɟ, ɨɛɪɚɬɧɨɦ ɪɟɝɢɫɬɪɚɰɢɢ. Ɂɚɩɢɫɵɜɚɸɬɫɹ ɢ ɨɱɢɳɚɸɬɫɹ ɛɭɮɟɪɵ ɨɬɤɪɵɬɵɯ ɮɚɣɥɨɜ, ɡɚɤɪɵɜɚɸɬɫɹ ɨɬɤɪɵɬɵɟ ɩɨɬɨɤɢ, ɢ ɭɩɪɚɜɥɟɧɢɟ ɜɨɡɜɪɚɳɚɟɬɫɹ
ɜ ɨɩɟɪɚɰɢɨɧɧɭɸ ɫɪɟɞɭ. Ʉɚɤɢɟ ɡɧɚɱɟɧɢɹ ɚɪɝɭɦɟɧɬɚ status ɩɟɪɟɞɚɜɚɬɶ ɜ ɫɪɟɞɭ –
ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ, ɨɞɧɚɤɨ ɧɭɥɶ ɨɛɳɟɩɪɢɧɹɬ ɤɚɤ ɫɢɝɧɚɥ ɭɫɩɟɲɧɨɝɨ
ɡɚɜɟɪɲɟ-
ɧɢɹ ɩɪɨɝɪɚɦɦɵ. Ɇɨɠɧɨ ɬɚɤɠɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɡɧɚɱɟɧɢɹ EXIT_ SUCCESS
(ɭɫɩɟɲɧɨɟ ɡɚɜɟɪɲɟɧɢɟ) ɢ EXIT_FAILURE (ɨɲɢɛɨɱɧɨɟ ɡɚɜɟɪɲɟɧɢɟ).
177
Ɏɭɧɤɰɢɹ atexit ɪɟɝɢɫɬɪɢɪɭɟɬ ɮɭɧɤɰɢɸ fCn ɞɥɹ ɜɵɡɨɜɚ ɩɪɢ ɧɨɪɦɚɥɶɧɨɦ ɡɚɜɟɪɲɟɧɢɢ ɩɪɨɝɪɚɦɦɵ; ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɟɫɥɢ ɪɟɝɢɫɬɪɚɰɢɹ
ɧɟɜɵɩɨɥɧɢɦɚ:
int atexit(void (*fcn)(void))
Ɏɭɧɤɰɢɹ system ɩɟɪɟɞɚɟɬ ɫɬɪɨɤɭ s ɜ ɨɩɟɪɚɰɢɨɧɧɭɸ ɫɪɟɞɭ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ:
int system(const char *s)
ȿɫɥɢ ɫɬɪɨɤɚ s ɪɚɜɧɚ NULL (ɩɭɫɬɚɹ ɫɬɪɨɤɚ) ɢ ɩɪɢ ɷɬɨɦ ɤɨɦɚɧɞɧɵɣ ɩɪɨɰɟɫɫɨɪ ɫɪɟɞɵ ɫɭɳɟɫɬɜɭɟɬ, ɬɨ system ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ. ȿɫɥɢ s –
ɧɟ NULL
, ɬɨ ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ.
Ɏɭɧɤɰɢɹ getenv ɜɨɡɜɪɚɳɚɟɬ ɫɬɪɨɤɭ ɫɪɟɞɵ, ɚɫɫɨɰɢɢɪɨɜɚɧɧɭɸ ɫ name,
ɢɥɢ NULL, ɟɫɥɢ ɬɚɤɨɣ ɫɬɪɨɤɢ ɧɟ ɫɭɳɟɫɬɜɭɟɬ:
char *getenv(const char *name)
Ɏɭɧɤɰɢɹ bsearch ɢɳɟɬ ɫɪɟɞɢ base[0]...base[n-1] ɷɥɟɦɟɧɬ, ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɤɥɸɱɭ ɩɨɢɫɤɚ *key:
void *bsearch(const void *key, const void
*base, sizet n, sizet size, int (*cmp)(const void
*keyval, const void *datum))
Ɏɭɧɤɰɢɹ ɫɪɚɜɧɟɧɢɹ cmp ɜɨɡɜɪɚɳɚɟɬ ɨɬɪɢɰɚɬɟɥɶɧɨɟ ɱɢɫɥɨ, ɟɫɥɢ ɟɟ ɩɟɪɜɵɣ
ɫɥɭɱɚɟ
ɚɪɝɭɦɟɧɬ (ɤɥɸɱ ɩɨɢɫɤɚ) ɦɟɧɶɲɟ ɜɬɨɪɨɝɨ (ɡɚɩɢɫɢ ɜ ɬɚɛɥɢɰɟ), ɧɭɥɶ ɜ
ɢɯ
ɪɚɜɟɧɫɬɜɚ ɢ ɩɨɥɨɠɢɬɟɥɶɧɨɟ ɱɢɫɥɨ, ɟɫɥɢ ɤɥɸɱ ɩɨɢɫɤɚ ɛɨɥɶɲɟ. ɗɥɟɦɟɧɬɵ ɦɚɫɫɢɜɚ base ɞɨɥɠɧɵ ɛɵɬɶ ɭɩɨɪɹɞɨɱɟɧɵ ɩɨ ɜɨɡɪɚɫɬɚɧɢɸ. Ɏɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɷɥɟɦɟɧɬ ɫ ɫɨɜɩɚɜɲɢɦ ɤɥɸɱɨɦ ɢɥɢ NULL, ɟɫɥɢ ɤɥɸɱ ɧɟ ɧɚɣɞɟɧ. Ɏɭɧɤɰɢɹ ɫɪɚɜɧɟɧɢɹ cmp ɞɨɥɠɧɚ ɢɦɟɬɶ ɬɟ ɠɟ ɩɚɪɚɦɟɬɪɵ, ɱɬɨ ɢ ɜ ɨɩɢɫɚɧɢɢ
bsearch.
Ɏɭɧɤɰɢɹ qsort ɫɨɪɬɢɪɭɟɬ ɦɚɫɫɢɜ
base[0] ...base[n-1]
ɨɛɴɟɤɬɨɜ
ɪɚɡɦɟɪɚ size ɜ ɩɨɪɹɞɤɟ ɜɨɡɪɚɫɬɚɧɢɹ:
void qsort(void *base, size t n,
sizet size (int (*cmp)(const void *,
const void *))
Ɏɭɧɤɰɢɹ abs ɜɨɡɜɪɚɳɚɟɬ ɚɛɫɨɥɸɬɧɨɟ ɡɧɚɱɟɧɢɟ ɫɜɨɟɝɨ ɚɪɝɭɦɟɧɬɚ ɬɢɩɚ
int:
int abs(int n)
Ɏɭɧɤɰɢɹ labs ɜɨɡɜɪɚɳɚɟɬ ɚɛɫɨɥɸɬɧɨɟ ɡɧɚɱɟɧɢɟ ɫɜɨɟɝɨ ɚɪɝɭɦɟɧɬɚ ɬɢɩɚ
long:
long labs(long n)
Ɏɭɧɤɰɢɹ div ɜɵɱɢɫɥɹɟɬ ɱɚɫɬɧɨɟ ɢ ɨɫɬɚɬɨɤ ɨɬ ɞɟɥɟɧɢɹ ɱɢɫɥɢɬɟɥɹ num ɧɚ
ɡɧɚɦɟɧɚɬɟɥɶ denom:
div_t div(int num, int denom)
Ɋɟɡɭɥɶɬɚɬɵ ɡɚɩɨɦɢɧɚɸɬɫɹ ɜ ɷɥɟɦɟɧɬɚɯ quot ɢ rem ɬɢɩɚ int ɫɬɪɭɤɬɭɪɵ
ɬɢɩɚ div_t.
Ɏɭɧɤɰɢɹ ldiv ɜɵɱɢɫɥɹɟɬ
ɱɚɫɬɧɨɟ
ɢ ɨɫɬɚɬɨɤ ɨɬ ɞɟɥɟɧɢɹ num ɧɚ denom:
ldiv_t ldiv(long numf, long denom)
178
Ɋɟɡɭɥɶɬɚɬɵ ɡɚɩɨɦɢɧɚɸɬɫɹ ɜ ɷɥɟɦɟɧɬɚɯ quot ɢ rem ɬɢɩɚ long ɫɬɪɭɤɬɭ-
ɪɵ ldiv_t.
Ⱥ.6. Ɇɚɤɪɨɫ ɞɥɹ ɞɢɚɝɧɨɫɬɢɤɢ
ɗɬɨɬ ɦɚɤɪɨɫ ɨɩɢɫɚɧ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɥɟ assert.h ɢ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ
ɜɤɥɸɱɟɧɢɹ ɜ ɩɪɨɝɪɚɦɦɭ ɫɪɟɞɫɬɜ ɞɢɚɝɧɨɫɬɢɤɢ:
void assert (int ɜɵɪɚɠɟɧɢɟ)
ȿɫɥɢ ɡɚɞɚɧɧɨɟ ɜɵɪɚɠɟɧɢɟ ɢɦɟɟɬ ɡɧɚɱɟɧɢɟ 0 ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɨɩɟɪɚɬɨɪɚ assert {ɜɵɪɚɠɟɧɢɟ), ɬɨ ɜ ɩɨɬɨɤ stderr ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɫɨɨɛɳɟɧɢɟ
ɩɪɢɦɟɪɧɨ ɫɥɟɞɭɸɳɟɝɨ ɜɢɞɚ:
Assertion failed: ɜɵɪɚɠɟɧɢɟ, file ɢɦɹ_ɮɚɣɥɚ,
line nnn
ɉɨɫɥɟ ɷɬɨɝɨ ɛɭɞɟɬ ɜɵɡɜɚɧɚ
ɮɭɧɤɰɢɹ abort ɞɥɹ ɡɚɜɟɪɲɟɧɢɹ ɪɚɛɨɬɵ. ɂɦɹ
ɢɫɯɨɞɧɨɝɨ ɮɚɣɥɚ ɢ ɧɨɦɟɪ ɫɬɪɨɤɢ ɛɟɪɭɬɫɹ ɢɡ ɦɚɤɪɨɫɨɜ ɩɪɟɩɪɨɰɟɫɫɨɪɚ FILE ɢ
LINE.
ȿɫɥɢ ɜ ɦɨɦɟɧɬ ɜɤɥɸɱɟɧɢɹ ɮɚɣɥɚ <assert.h> ɢɦɹ NDEBUG ɹɜɥɹɟɬɫɹ
ɨɩɪɟɞɟɥɟɧɧɵɦ, ɬɨ ɦɚɤɪɨɫ assert ɢɝɧɨɪɢɪɭɟɬɫɹ.
Ⱥ.7. ɋɢɫɬɟɦɧɨ ɡɚɜɢɫɢɦɵɟ ɤɨɧɫɬɚɧɬɵ
ȼ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ <limits.h> ɨɩɪɟɞɟɥɹɸɬɫɹ ɤɨɧɫɬɚɧɬɵ, ɨɩɢɫɵɜɚ-
ɸɳɢɟ ɪɚɡɦɟɪɵ ɰɟɥɨɱɢɫɥɟɧɧɵɯ ɬɢɩɨɜ. ȼ ɬɚɛɥɢɰɟ Ⱥ.4 ɩɪɢɜɟɞɟɧɵ ɦɢɧɢɦɚɥɶɧɨ
ɞɨɩɭɫɬɢɦɵɟ ɜɟɥɢɱɢɧɵ, ɚ ɜ ɤɨɧɤɪɟɬɧɵɯ ɪɟɚɥɢɡɚɰɢɹɯ ɜɨɡɦɨɠɧɵ ɡɧɚɱɟɧɢɹ, ɛɨɥɶɲɢɟ ɭɤɚɡɚɧɧɵɯ.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ Ⱥ.4
Ɋɚɡɦɟɪɵ ɰɟɥɨɱɢɫɥɟɧɧɵɯ ɬɢɩɨɜ ɞɚɧɧɵɯ
Ʉɨɧɫɬɚɧɬɚ Ɂɧɚɱɟɧɢɟ Ɉɩɢɫɚɧɢɟ
CHAR_BIT 8 Ȼɢɬɨɜ ɜ char
SCHAR_MAX
CHAR_MIN
uchar_max ɢɥɢ
SCHAR_MAX
0 ɢɥɢ
CHAR_MIN
Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ char
Ɇɢɧɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ char
INT_MAX +32767 Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ int
INT_MIN –32767 Ɇɢɧɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ int
LONG_MAX +2147483647 Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ long
LONG_MIN –2147483647 Ɇɢɧɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ long
SCHAR_MAX +127 Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ signed char
SCHAR_MIN –127 Ɇɢɧɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ signed char
SHRT_MAX +32767 Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ short
179
Ɉ ɤ ɨ ɧ ɱ ɚ ɧ ɢ ɟ ɬ ɚ ɛ ɥ ɢ ɰ ɵ Ⱥ.4
Ʉɨɧɫɬɚɧɬɚ Ɂɧɚɱɟɧɢɟ Ɉɩɢɫɚɧɢɟ
SHRT_MIN –32767 Ɇɢɧɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ short
UCHAR_MAX 255
Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ unsigned
UINT_MAX 65535 Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ unsigned int
ULONG_MAX 4294967295
USHRT_MAX 65535
Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ unsigned
Ɇɚɤɫɢɦɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ unsigned
ɂɦɟɧɚ, ɩɪɢɜɟɞɟɧɧɵɟ ɜ ɬɚɛɥɢɰɟ Ⱥ.5, ɜɡɹɬɵ ɢɡ ɮɚɣɥɚ float.h ɢ ɹɜɥɹɸɬɫɹ
ɤɨɧɫɬɚɧɬɚɦɢ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɜɟɳɟɫɬɜɟɧɧɨɣ ɚɪɢɮɦɟɬɢɤɟ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ. ɂɦɟɧɚ ɫ ɩɪɟɮɢɤɫɨɦ FLT ɨɬɧɨɫɹɬɫɹ ɤ ɜɟɥɢɱɢɧɚɦ ɬɢɩɚ float, ɚ ɫ ɩɪɟɮɢɤɫɨɦ DBL – ɤ ɜɟɥɢɱɢɧɚɦ ɬɢɩɚ double. Ɋɚɡɥɢɱɧɵɟ ɪɟɚɥɢɡɚɰɢɢ ɛɢɛɥɢɨɬɟɤɢ
ɭɫɬɚɧɚɜɥɢɜɚɸɬ ɫɜɨɢ ɡɧɚɱɟɧɢɹ.
Ɍ ɚ ɛ ɥ ɢ ɰ
ɚ Ⱥ.5
Ɋɚɡɦɟɪɵ ɜɟɳɟɫɬɜɟɧɧɵɯ ɬɢɩɨɜ ɞɚɧɧɵɯ
Ʉɨɧɫɬɚɧɬɚ Ɂɧɚɱɟɧɢɟ Ɉɩɢɫɚɧɢɟ
FLT_RADIX 2
FLT_ROUNDS
Ɉɫɧɨɜɚɧɢɟ ɞɥɹ ɷɤɫɩɨɧɟɧɰɢɚɥɶɧɨɣ
ɮɨɪɦɵ ɩɪɟɞɫɬɚɜɥɟɧɢɹ, ɧɚɩɪɢɦɟɪ, 2,16
Ɋɟɠɢɦ ɨɤɪɭɝɥɟɧɢɹ ɩɪɢ ɫɥɨɠɟɧɢɢ ɱɢɫɟɥ
ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
FLT_DIG 6 Ɍɨɱɧɨɫɬɶ (ɤɨɥɢɱɟɫɬɜɨ ɞɟɫɹɬɢɱɧɵɯ ɰɢɮɪ)
FLT_EPSILON 1E-5
FLT_MANT_DIG
ɇɚɢɦɟɧɶɲɟɟ ɱɢɫɥɨ ɯ ɬɚɤɨɟ, ɱɬɨ 1,0 + ɯ *
1,0
Ʉɨɥɢɱɟɫɬɜɨ ɰɢɮɪ ɩɨ ɨɫɧɨɜɚɧɢɸ
FLT_RADIX ɜ ɦɚɧɬɢɫɫɟ
FLT_MAX 1ȿ+37 ɇɚɢɛɨɥɶɲɟɟ ɱɢɫɥɨ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
n
FLT_MAX_EXP
FLT_MIN 1ȿ-37
FLT_MIN_EXP
ɇɚɢɛɨɥɶɲɟɟ n – ɬɚɤɨɟ, ɱɬɨ FLT_RADIX
1 ɩɪɟɞɫɬɚɜɢɦɨ
ɇɚɢɦɟɧɶɲɟɟ ɧɨɪɦɚɥɢɡɨɜɚɧɧɨɟ ɱɢɫɥɨ ɫ
ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
ɇɚɢɦɟɧɶɲɟɟ n – ɬɚɤɨɟ, ɱɬɨ 10
ɧɨɪɦɚɥɢɡɨɜɚɧɧɨɟ ɱɢɫɥɨ
n
–
-
DBL_DIG 10 Ʉɨɥɢɱɟɫɬɜɨ ɡɧɚɱɚɳɢɯ ɞɟɫɹɬɢɱɧɵɯ ɰɢɮɪ
DBL_EPSILON 1E-9
ɇɚɢɦɟɧɶɲɟɟ ɯ – ɬɚɤɨɟ, ɱɬɨ 1,0 + ɯ 1,0,
ɝɞɟ x – double
Ʉɨɥɢɱɟɫɬɜɨ ɰɢɮɪ ɩɨ ɨɫɧɨɜɚɧɢɸ
DBL_MANT_DIG
FLT_RADIX ɜ ɦɚɧɬɢɫɫɟ ɞɥɹ ɱɢɫɟɥ ɬɢɩɚ
double
180
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]