Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
Ɉ ɤ ɨ ɧ ɱ ɚ ɧ ɢ ɟ ɬ ɚ ɛ ɥ ɢ ɰ ɵ 3.2
ɋɢɦɜɨɥ Ɂɧɚɱɟɧɢɟ
%G
ȼ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɨɝɨ, ɤɚɤɨɣ ɜɵɜɨɞ ɛɭɞɟɬ ɤɨɪɨɱɟ, ɢɫɩɨɥɶɡɭɟɬɫɹ
%ȿ ɢɥɢ %F
%o ȼɨɫɶɦɟɪɢɱɧɨɟ ɛɟɡ ɡɧɚɤɚ
%s ɋɬɪɨɤɚ ɫɢɦɜɨɥɨɜ
%u Ⱦɟɫɹɬɢɱɧɨɟ ɰɟɥɨɟ ɛɟɡ ɡɧɚɤɚ
%x ɒɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɟ ɛɟɡ ɡɧɚɤɚ (ɛɭɤɜɵ ɜ ɧɢɠɧɟɦ ɪɟɝɢɫɬɪɟ)
%X ɒɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɟ ɛɟɡ ɡɧɚɤɚ (ɛɭɤɜɵ ɜ ɜɟɪɯɧɟɦ ɪɟɝɢɫɬɪɟ)
%p ȼɵɜɨɞ ɭɤɚɡɚɬɟɥɹ
Ⱥɪɝɭɦɟɧɬ, ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɷɬɨɦɭ ɫɩɟɰɢɮɢɤɚɬɨɪɭ, ɞɨɥɠɟɧ
%n
ɛɵɬɶ ɭɤɚɡɚɬɟɥɟɦ ɧɚ ɰɟɥɨɱɢɫɥɟɧɧɭɸ ɩɟɪɟɦɟɧɧɭɸ, ɱɬɨ
ɩɨɡɜɨɥɹɟɬ ɫɨɯɪɚɧɢɬɶ ɜ ɧɟɣ ɤɨɥɢɱɟɫɬɜɨ ɫɢɦɜɨɥɨɜ,
ɡɚɩɢɫɚɧɧɵɯ ɞɨ ɬɨɣ ɩɨɡɢɰɢɢ, ɜ ɤɨɬɨɪɨɣ ɧɚɯɨɞɢɬɫɹ ɤɨɞ %n
%% ȼɵɜɨɞɢɬ ɡɧɚɤ %
Ɇɟɠɞɭ ‘%’ ɢ ɫɢɦɜɨɥɨɦ-ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ ɦɨɝɭɬ ɛɵɬɶ ɪɚɫɩɨɥɨɠɟɧɵ (ɜ ɭɤɚ-
ɡɚɧɧɨɦ ɧɢɠɟ ɩɨɪɹɞɤɟ) ɫɥɟɞɭɸɳɢɟ ɷɥɟɦɟɧɬɵ:
ɡɧɚɤ ɦɢɧɭɫɚ, ɨɛɟɫɩɟɱɢɜɚɸɳɢɣ ɜɵɪɚɜɧɢɜɚɧɢɟ ɚɪɝɭɦɟɧɬɚ ɩɨ ɥɟɜɨɦɭ ɤɪɚɸ
ɩɨɥɹ;
ɱɢɫɥɨ, ɡɚɞɚɸɳɟɟ ɦɢɧɢɦɚɥɶɧɭɸ ɲɢɪɢɧɭ ɩɨɥɹ. Ʌɢɲɧɢɟ ɩɨɡɢɰɢɢ ɫɥɟɜɚ
(ɢɥɢ ɫɩɪɚɜɚ ɩɪɢ ɥɟɜɨɫɬɨɪɨɧɧɟɦ ɪɚɫɩɨɥɨɠɟɧɢɢ) ɛɭɞɭɬ ɡɚɩɨɥɧɟɧɵ ɩɪɨɛɟɥɚɦɢ;
ɬɨɱɤɚ, ɨɬɞɟɥɹɸɳɚɹ ɲɢɪɢɧɭ ɩɨɥɹ ɨɬ ɜɟɥɢɱɢɧɵ, ɭɫɬɚɧɚɜɥɢɜɚɸɳɟɣ
ɬɨɱ-
ɧɨɫɬɶ;
ɱɢɫɥɨ (ɬɨɱɧɨɫɬɶ), ɭɤɚɡɵɜɚɸɳɟɟ ɦɚɤɫɢɦɚɥɶɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɩɟɱɚɬɚɟɦɵɯ
ɫɢɦɜɨɥɨɜ ɜ ɫɬɪɨɤɟ, ɢɥɢ ɤɨɥɢɱɟɫɬɜɨ ɰɢɮɪ ɩɨɫɥɟ ɞɟɫɹɬɢɱɧɨɣ ɬɨɱɤɢ ɞɥɹ ɱɢɫɟɥ ɫ
ɩɥɚɜɚɸɳɟɣ ɡɚɩɹɬɨɣ, ɢɥɢ ɦɢɧɢɦɚɥɶɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɰɢɮɪ ɞɥɹ ɰɟɥɨɝɨ;
ɛɭɤɜɚ h, ɟɫɥɢ ɩɟɱɚɬɚɟɦɨɟ ɰɟɥɨɟ ɞɨɥɠɧɨ ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ short, ɢɥɢ
l (ɥɚɬɢɧɫɤɚɹ ɛɭɤɜɚ ell), ɟɫɥɢ ɰɟɥɨɟ ɞɨɥɠɧɨ ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ long.
ɒɢɪɢɧɭ ɢ ɬɨɱɧɨɫɬɶ ɦɨɠɧɨ ɡɚɞɚɬɶ ɫ ɩɨɦɨɳɶɸ ɫɢɦɜɨɥɚ *, ɡɧɚɱɟɧɢɟ ɲɢɪɢɧɵ
(ɢɥɢ ɬɨɱɧɨɫɬɢ) ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɛɟɪɟɬɫɹ ɢɡ ɫɥɟɞɭɸɳɟɝɨ ɚɪɝɭɦɟɧɬɚ (ɤɨɬɨɪɵɣ ɞɨɥ-
ɠɟɧ ɛɵɬɶ ɬɢɩɚ int). ɇɚɩɪɢɦɟɪ, ɱɬɨɛɵ ɧɚɩɟɱɚɬɚɬɶ ɧɟ ɛɨɥɟɟ max ɫɢɦɜɨɥɨɜ ɢɡ
ɫɬɪɨɤɢ s, ɢɫɩɨɥɶɡɭɣɬɟ ɨɩɟɪɚɬɨɪ:
printf("%.*s", max, s);
ɉɭɫɬɶ ɢɦɟɟɬɫɹ ɫɬɪɨɤɚ "hello, world", ɫɨɞɟɪɠɚɳɚɹ 12 ɫɢɦɜɨɥɨɜ. ɇɢɠɟ
ɩɨɤɚɡɚɧɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɪɚɡɥɢɱɧɵɯ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢ ɩɨɤɚɡɵɜɚɟɬɫɹ
ɢɯ ɜɥɢɹɧɢɟ
ɧɚ ɩɟɱɚɬɶ ɷɬɨɣ ɫɬɪɨɤɢ. ɉɨɥɟ ɫɩɟɰɢɚɥɶɧɨ ɨɛɪɚɦɥɟɧɨ ɞɜɨɟɬɨɱɢɹɦɢ, ɱɬɨɛɵ ɛɵɥɚ
ɜɢɞɧɚ ɟɝɨ ɞɥɢɧɚ.
:%s: :hello, world: :%10s: :hello, world:
:%.10s: :hello, wor: :%-10s: :hello, world:
:%.15s: :hello, world: :%-15s: :hello, world : :%15.10s:
: hello, wor: :%-15.10s: :hello, wor :
81
ɑɢɫɥɚ ɜ ɞɟɫɹɬɢɱɧɨɦ ɮɨɪɦɚɬɟ ɫɨ ɡɧɚɤɨɦ ɨɬɨɛɪɚɠɚɸɬɫɹ ɫ ɩɨɦɨɳɶɸ ɫɩɟɰɢɮɢɤɚɬɨɪɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ %d ɢɥɢ %i. Ⱦɥɹ ɜɵɜɨɞɚ ɰɟɥɨɝɨ ɡɧɚɱɟɧɢɹ ɛɟɡ ɡɧɚɤɚ
ɢɫɩɨɥɶɡɭɣɬɟ %u.
ɋɩɟɰɢɮɢɤɚɬɨɪ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ %f ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɜɵɜɨɞɚ ɱɢɫɟɥ ɜ ɮɨɪɦɚɬɟ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ. ɋɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɚɪɝɭɦɟɧɬ ɞɨɥɠɟɧ ɢɦɟɬɶ ɬɢɩ dou-
ble.
ɉɪɢɦɟɧɟɧɢɟ ɫɩɟɰɢɮɢɤɚɬɨɪɚ %g ɩɨɤɚɡɚɧɨ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 3.5. Ɏɨɪɦɚɬɢɪɨɜɚɧɧɵɣ
ɜɵɜɨɞ ɜɟɳɟɫɬɜɟɧɧɵɯ ɱɢɫɟɥ.
#include <stdio.h>
int main(void) {
double f;
for(f=1.0; f<1.0e+8; f=f*10) printf("%g ", f); return
0;
}
// ȼ ɪɟɡɭɥɶɬɚɬɟ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɩɨɥɭɱɢɦ:
// 1 10 100 1000 10000 100000 1e+06 1e+07
ɍ ɮɭɧɤɰɢɢ printf() ɢɦɟɟɬɫɹ ɜɨɡɦɨɠɧɨɫɬɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɜɚ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɦɨɞɢɮɢɤɚɬɨɪɚ: ‘*’ ɢ ‘#’.
Ɋɚɡɦɟɳɟɧɢɟ ‘#’ ɩɟɪɟɞ ɫɩɟɰɢɮɢɤɚɬɨɪɚɦɢ g, G, f, ȿ ɢɥɢ e ɨɡɧɚɱɚɟɬ, ɱɬɨ
ɩɪɢ ɜɵɜɨɞɟ ɨɛɹɡɚɬɟɥɶɧɨ ɛɭɞɟɬ ɩɨɤɚɡɚɧɚ ɞɟɫɹɬɢɱɧɚɹ ɡɚɩɹɬɚɹ – ɞɚɠɟ ɟɫɥɢ ɞɟɫɹɬɢɱɧɵɯ ɰɢɮɪ ɧɟɬ. ȿɫɥɢ ɪɚɡɦɟɫɬɢɬɶ
‘#’ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɩɟɪɟɞ ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ x
ɢɥɢ X, ɬɨ ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɟ ɱɢɫɥɨ ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɫ ɩɪɟɮɢɤɫɨɦ 0x. ȿɫɥɢ ‘#’
ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɡɚɩɢɫɚɧ ɩɟɪɟɞ ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ o, ɱɢɫɥɨ ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɫ
ɜɟɞɭɳɢɦ ɧɭɥɟɦ. Ʉ ɥɸɛɵɦ ɞɪɭɝɢɦ ɫɩɟɰɢɮɢɤɚɬɨɪɚɦ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɦɨɞɢɮɢɤɚɬɨɪ ‘#’ ɩɪɢɦɟɧɹɬɶ ɧɟɥɶɡɹ.
Ɇɨɞɢɮɢɤɚɬɨɪɵ ɦɢɧɢɦɚɥɶɧɨɣ ɲɢɪɢɧɵ ɩɨɥɹ ɢ ɬɨɱɧɨɫɬɢ ɦɨɠɧɨ ɩɟɪɟɞɚɜɚɬɶ
ɮɭɧɤɰɢɢ printf() ɧɟ ɤɚɤ ɤɨɧɫɬɚɧɬɵ,
ɚ ɤɚɤ ɚɪɝɭɦɟɧɬɵ, ɢɫɩɨɥɶɡɭɹ ɜ ɤɚɱɟɫɬɜɟ
ɡɚɩɨɥɧɢɬɟɥɹ ɫɢɦɜɨɥ ‘*’. ɉɪɢ ɫɤɚɧɢɪɨɜɚɧɢɢ ɫɬɪɨɤɢ ɮɨɪɦɚɬɚ ɮɭɧɤɰɢɹ
printf() ɤɚɠɞɨɣ ɡɜɟɡɞɨɱɤɟ ɢɡ ɷɬɨɣ ɫɬɪɨɤɢ ɛɭɞɟɬ ɫɬɚɜɢɬɶ ɜ ɫɨɨɬɜɟɬɫɬɜɢɟ ɨɱɟɪɟɞɧɨɣ ɚɪɝɭɦɟɧɬ, ɩɪɢɱɟɦ ɜ ɬɨɦ ɠɟ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɪɚɫɩɨɥɨɠɟɧɵ ɚɪɝɭɦɟɧɬɵ.
ɉɪɢɦɟɪ 3.6. Ɋɚɫɲɢɪɟɧɢɟ ɜɵɜɨɞɚ.
// ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɦɨɞɢɮɢɤɚɬɨɪɚ *
#include <stdio.h>
int main(void) {
printf("%*.*f", 10, 4, 1234.56);
return 0;
}
// Ɋɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ
// 1234.5600
ɇɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ
ɡɧɚɱɢɬɟɥɶɧɚɹ ɱɚɫɬɶ ɫɩɟɰɢɮɢɤɚɬɨɪɨɜ ɞɥɹ ɮɭɧɤɰɢɣ
scanf ɢ printf ɫɨɜɩɚɞɚɸɬ, ɧɟ ɡɚɛɵɜɚɣɬɟ ɫɜɟɪɢɬɶɫɹ ɫ ɬɚɛɥɢɰɚɦɢ 3.1 ɢ 3.2
ɩɟɪɟɞ ɜɵɛɨɪɨɦ ɮɨɪɦɚɬɚ ɜɜɨɞ-ɜɵɜɨɞɚ.
82
3.2. Ⱦɢɫɤɨɜɵɟ ɧɚɤɨɩɢɬɟɥɢ
ȼ ɧɚɫɬɨɹɳɟɟ ɜɪɟɦɹ ɬɚɤɢɟ ɧɚɤɨɩɢɬɟɥɢ, ɤɚɤ ɝɢɛɤɢɟ ɞɢɫɤɢ (ɞɢɫɤɟɬɵ), ɭɠɟ ɧɟ
ɢɫɩɨɥɶɡɭɸɬɫɹ. ɉɨɷɬɨɦɭ ɜɫɹ ɢɧɮɨɪɦɚɰɢɹ, ɩɪɢɜɟɞɟɧɧɚɹ ɜ ɞɚɧɧɨɦ ɩɨɞɪɚɡɞɟɥɟ, ɤɚɫɚɟɬɫɹ ɬ. ɧ. «ɠɟɫɬɤɢɯ» ɞɢɫɤɨɜ.
Ʉɨɧɫɬɪɭɤɬɢɜɧɨ ɠɟɫɬɤɢɣ ɞɢɫɤ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɧɚɛɨɪ ɤɪɭɝɥɵɯ ɚɥɸɦɢɧɢɟɜɵɯ ɩɥɚɫɬɢɧ, ɩɨɤɪɵɬɵɯ ɦɚɝɧɢɬɧɵɦ ɦɚɬɟɪɢɚɥɨɦ, ɤɨɬɨɪɵɟ ɜɪɚɳɚɸɬɫɹ ɧɚ
ɲɩɢɧɞɟɥɟ, ɩɪɢɜɨɞɢɦɨɦ ɜɨ ɜɪɚɳɟɧɢɟ ɷɥɟɤɬɪɨɞɜɢɝɚɬɟɥɟɦ.
Ɇɢɧɢɦɚɥɶɧɨɣ ɟɞɢɧɢɰɟɣ ɯɪɚɧɟɧɢɹ ɢɧɮɨɪɦɚɰɢɢ ɧɚ
(sector), ɢɦɟɸɳɢɣ ɪɚɡɦɟɪ, ɪɚɜɧɵɣ 2
n
, ɝɞɟ n – ɰɟɥɨɟ ɱɢɫɥɨ. Ɋɚɡɥɢɱɚɸɬ ɮɢɡɢɱɟ-
ɞɢɫɤɟ ɹɜɥɹɟɬɫɹ ɫɟɤɬɨɪ
ɫɤɢɟ ɢ ɥɨɝɢɱɟɫɤɢɟ ɫɟɤɬɨɪɵ. Ɂɚɩɢɫɚɬɶ ɮɪɚɝɦɟɧɬ ɢɧɮɨɪɦɚɰɢɢ ɪɚɡɦɟɪɨɦ ɦɟɧɶɲɟ,
ɱɟɦ ɫɟɤɬɨɪ, ɧɟɥɶɡɹ. ȿɫɥɢ, ɧɚɩɪɢɦɟɪ, ɪɚɡɦɟɪ ɫɟɤɬɨɪɚ ɪɚɜɟɧ 512 ɛɚɣɬ, ɚ ɪɚɡɦɟɪ
ɮɚɣɥɚ, ɤɨɬɨɪɵɣ ɧɭɠɧɨ ɫɨɯɪɚɧɢɬɶ ɧɚ ɞɢɫɤɟ, ɫɨɫɬɚɜɥɹɟɬ 514 ɛɚɣɬ, ɬɨ ɧɚ ɞɢɫɤɟ
ɷɬɨɬ ɮɚɣɥ ɛɭɞɟɬ ɡɚɧɢɦɚɬɶ 2 ɫɟɤɬɨɪɚ, ɬ. ɟ. 512 + 512 = 1024 ɛɚɣɬ.
ɋɟɤɬɨɪɵ ɨɛɴɟɞɢɧɟɧɵ ɜ ɞɨɪɨɠɤɢ, ɝɪɭɩɩɚ ɞɨɪɨɠɟɤ
ɧɚɡɵɜɚɟɬɫɹ ɰɢɥɢɧɞɪɨɦ.
Ɏɢɡɢɱɟɫɤɢ ɰɢɥɢɧɞɪ ɜɤɥɸɱɚɟɬ ɜɫɟ ɞɨɪɨɠɤɢ ɫ ɨɞɢɧɚɤɨɜɵɦɢ ɧɨɦɟɪɚɦɢ ɧɚ ɜɫɟɯ
ɩɥɚɫɬɢɧɚɯ ɠɟɫɬɤɨɝɨ ɞɢɫɤɚ. ɉɪɢ ɷɬɨɦ ɝɪɭɩɩɵ ɰɢɥɢɧɞɪɨɜ ɦɨɝɭɬ ɨɬɧɨɫɢɬɶɫɹ ɤ
ɪɚɡɥɢɱɧɵɦ ɨɩɟɪɚɰɢɨɧɧɵɦ ɫɢɫɬɟɦɚɦ. Ʉɪɨɦɟ ɬɨɝɨ, ɞɨɩɭɫɤɚɟɬɫɹ ɪɚɡɞɟɥɹɬɶ ɮɢɤɫɢɪɨɜɚɧɧɵɣ ɞɢɫɤ ɧɚ ɧɟɫɤɨɥɶɤɨ ɪɚɡɞɟɥɨɜ ɪɚɡɧɨɝɨ ɪɚɡɦɟɪɚ. ɂɧɮɨɪɦɚɰɢɹ ɫ ɩɥɚɫɬɢɧ ɧɚ ɞɢɫɤɟ ɫɱɢɬɵɜɚɟɬɫɹ ɝɨɥɨɜɤɚɦɢ. Ⱥɞɪɟɫ ɮɢɡɢɱɟɫɤɨɝɨ ɫɟɤɬɨɪɚ ɡɚɞɚɟɬɫɹ ɜ
ɮɨɪɦɚɬɟ
:
ɋɟɤɬɨɪ – ɐɢɥɢɧɞɪ.
Ʌɨɝɢɱɟɫɤɢɟ ɫɟɤɬɨɪɵ ɢɦɟɸɬ ɧɨɦɟɪɚ ɨɬ 0 ɞɨ N. ȼ ɩɪɨɝɪɚɦɦɟ ɩɪɢ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɦ ɞɨɫɬɭɩɟ ɤ ɞɢɫɤɭ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɤ ɮɢɡɢɱɟɫɤɭɸ, ɬɚɤ ɢ ɥɨɝɢɱɟɫɤɭɸ ɚɞɪɟɫɚɰɢɸ. ɂɧɮɨɪɦɚɰɢɹ ɨ ɫɟɤɬɨɪɚɯ ɯɪɚɧɢɬɫɹ ɧɚ ɫɚɦɨɦ ɞɢɫɤɟ ɢ ɡɚɩɢɫɵɜɚɟɬɫɹ ɩɪɢ ɟɝɨ ɮɨɪɦɚɬɢɪɨɜɚɧɢɢ, ɢ ɜɤɥɸɱɚɟɬ ɢɞɟɧɬɢɮɢɤɚɰɢɨɧɧɵɣ ɧɨɦɟɪ ɤɚɠɞɨɝɨ
ɫɟɤɬɨɪɚ. Ȼɚɡɨɜɚɹ ɫɢɫɬɟɦɚ ɜɜɨɞɚ-ɜɵɜɨɞɚ (BIOS) ɧɭɦɟɪɭɟɬ ɫɟɤɬɨɪɵ
ɞɢɫɤɚ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ: 1-8, 1-9 ɢɥɢ 1-15, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɟɦɤɨɫɬɢ ɞɢɫɤɚ. Ⱦɨɪɨɠɤɢ ɧɟ
ɧɭɦɟɪɭɸɬɫɹ, ɬ. ɤ. ɢɯ ɢɧɞɟɤɫ ɨɩɪɟɞɟɥɹɟɬɫɹ ɩɨ ɫɦɟɳɟɧɢɸ ɝɨɥɨɜɤɢ ɨɬ ɜɧɟɲɧɟɝɨ
ɤɪɚɹ ɞɢɫɤɚ.
Ⱦɢɫɤɨɜɵɟ ɮɭɧɤɰɢɢ BIOS ɨɛɪɚɳɚɸɬɫɹ ɤ ɨɩɪɟɞɟɥɟɧɧɨɦɭ ɫɟɤɬɨɪɭ, ɭɤɚɡɵɜɚɹ
ɟɝɨ ɧɨɦɟɪ ɢ ɧɨɦɟɪ ɞɨɪɨɠɤɢ. Ɏɭɧɤɰɢɢ DOS ɪɚɫɫɦɚɬɪɢɜɚɸɬ ɜɫɟ ɫɟɤɬɨɪɵ ɞɢɫɤɚ,
ɤɚɤ ɟɞɢɧɵɣ ɦɚɫɫɢɜ, ɢɧɞɟɤɫɵ ɜ ɤɨɬɨɪɨɦ ɪɚɫɩɨɥɨɠɟɧɵ ɩɨɞɪɹɞ, ɧɚɱɢɧɚɹ
ɨɬ 0, ɢ
ɬɚɤɢɦ ɨɛɪɚɡɨɦ ɤɚɠɞɵɣ ɫɟɤɬɨɪ ɢɦɟɟɬ ɫɜɨɣ ɥɨɝɢɱɟɫɤɢɣ ɧɨɦɟɪ.
Ɏɢɤɫɢɪɨɜɚɧɧɵɟ ɞɢɫɤɢ ɢɦɟɸɬ ɝɥɚɜɧɭɸ ɡɚɩɢɫɶ ɡɚɝɪɭɡɤɢ, ɤɨɬɨɪɚɹ ɫɨɞɟɪɠɢɬ
ɬɚɛɥɢɰɭ ɪɚɡɞɟɥɨɜ, ɩɨɡɜɨɥɹɸɳɭɸ ɪɚɡɞɟɥɢɬɶ ɞɢɫɤ ɦɟɠɞɭ ɧɟɫɤɨɥɶɤɢɦɢ ɨɩɟɪɚɰɢɨɧɧɵɦɢ ɫɢɫɬɟɦɚɦɢ.
Ɍɚɛɥɢɰɚ ɪɚɡɞɟɥɨɜ ɫɨɞɟɪɠɢɬ ɢɧɮɨɪɦɚɰɢɸ o ɬɨɦ, ɝɞɟ ɧɚ ɞɢɫɤɟ ɧɚɱɢɧɚɟɬɫɹ
ɪɚɡɞɟɥ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ, ɩɪɢ ɷɬɨɦ ɩɟɪɜɵɣ ɫɟɤɬɨɪ ɤɚɠɞɨɝɨ ɪɚɡɞɟɥɚ ɫɨɞɟɪɠɢɬ ɡɚɩɢɫɶ
ɧɚɱɚɥɶɧɨɣ ɡɚɝɪɭɡɤɢ.
Ɍɚɛɥɢɰɚ ɪɚɡɦɟɳɟɧɢɹ ɮɚɣɥɨɜ ɜɫɟɝɞɚ ɧɚɱɢɧɚɟɬɫɹ ɫ ɩɟɪɜɨɝɨ ɥɨɝɢɱɟɫɤɨɝɨ ɫɟɤɬɨɪɚ (ɜɬɨɪɨɣ ɫɟɤɬɨɪ ɞɢɫɤɟɬɵ ɢɥɢ ɪɚɡɞɟɥɚ ɮɢɤɫɢɪɨɜɚɧɧɨɝɨ ɞɢɫɤɚ), ɤɨɬɨɪɵɣ ɪɚɫɩɨɥɨɠɟɧ ɫɪɚɡɭ ɩɨɫɥɟ ɛɥɨɤɚ ɧɚɱɚɥɶɧɨɣ ɡɚɝɪɭɡɤɢ. ȿɫɥɢ ɬɚɛɥɢɰɚ ɡɚɧɢɦɚɟɬ ɛɨɥɟɟ
ɨɞɧɨɝɨ ɫɟɤɬɨɪɚ, ɬɨ ɨɧɚ ɩɪɨɞɨɥɠɚɟɬɫɹ ɜ ɫɥɟɞɭɸɳɢɯ ɫɟɤɬɨɪɚɯ.
83
3.2.1. Ɋɚɛɨɬɚ ɫ ɞɢɫɤɚɦɢ
Ⱦɢɫɤɨɜɚɹ ɫɥɭɠɛɚ ɩɨɞɪɚɡɞɟɥɹɟɬ ɮɢɡɢɱɟɫɤɢɟ ɞɢɫɤɢ ɧɚ ɝɢɛɤɢɟ ɞɢɫɤɢ (ɞɢɫɤɟɬɵ) ɢ ɠɟɫɬɤɢɟ ɞɢɫɤɢ. Ʉɪɨɦɟ ɞɢɫɤɨɜɨɣ ɫɥɭɠɛɵ ɫ ɞɢɫɤɨɜɵɦɢ ɭɫɬɪɨɣɫɬɜɚɦɢ ɫɜɹɡɚɧɵ ɬɚɤɠɟ ɜɟɤɬɨɪɵ, ɨɛɫɥɭɠɢɜɚɸɳɢɟ ɚɩɩɚɪɚɬɧɵɟ ɩɪɟɪɵɜɚɧɢɹ ɨɬ ɤɨɧɬɪɨɥɥɟɪɚ
ɝɢɛɤɢɯ ɞɢɫɤɨɜ – int 0Eh (ɥɢɧɢɹ IRQ6) ɢ ɨɬ ɤɨɧɬɪɨɥɥɟɪɚ ɠɟɫɬɤɢɯ ɞɢɫɤɨɜ –
int 76h (ɥɢɧɢɹ IRQ 14). ɉɪɢ ɧɚɥɢɱɢɢ ɞɜɭɯɤɚɧɚɥɶɧɨɝɨ ɩɨɪɬɚ ȺɌȺ (Advanced
Technology Attachment – ɩɚɪɚɥɥɟɥɶɧɵɣ ɢɧɬɟɪɮɟɣɫ ɩɨɞɤɥɸɱɟɧɢɹ ɠɺɫɬɤɢɯ ɞɢɫ-
ɤɨɜ
ɢ ɨɩɬɢɱɟɫɤɢɯ ɞɢɫɤɨɜɨɞɨɜ ɤ ɤɨɦɩɶɸɬɟɪɭ) ɜɬɨɪɨɣ ɤɚɧɚɥ ɨɛɵɱɧɨ ɡɚɞɟɣɫɬɜɭɟɬ
ɥɢɧɢɸ IRQ 15 (ɜɟɤɬɨɪ int 77h).
Ⱥɩɩɚɪɚɬɧɵɟ ɩɪɟɪɵɜɚɧɢɹ ɜɵɪɚɛɚɬɵɜɚɸɬɫɹ ɤɨɧɬɪɨɥɥɟɪɚɦɢ ɩɨ ɡɚɜɟɪɲɟɧɢɢ
(ɧɨɪɦɚɥɶɧɨɦɭ ɢɥɢ ɚɜɚɪɢɣɧɨɦɭ) ɜɧɭɬɪɟɧɧɢɯ ɨɩɟɪɚɰɢɣ. ɇɚ ɷɬɢ ɩɪɟɪɵɜɚɧɢɹ BIOS
ɧɟ ɪɟɚɝɢɪɭɟɬ, ɚ ɩɪɢ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɢɯ ɜɟɤɬɨɪɵ ɧɚɩɪɚɜɥɹɸɬɫɹ ɧɚ ɩɪɨɝɪɚɦɦɧɭɸ
ɡɚɝɥɭɲɤɭ (ɜ Ⱥɫɫɟɦɛɥɟɪɟ – ɢɧɫɬɪɭɤɰɢɸ IRET).
Ɋɚɫɫɦɨɬɪɢɦ ɮɭɧɤɰɢɢ ɛɢɛɥɢɨɬɟɤ ɹɡɵɤɚ ɋɢ ɞɥɹ ɪɚɛɨɬɵ ɫ ɞɢɫɤɚɦɢ.
ɉɨɥɭɱɢɬɶ
ɧɨɦɟɪ ɬɟɤɭɳɟɝɨ ɞɢɫɤɚ ɩɨɡɜɨɥɹɟɬ ɮɭɧɤɰɢɹ int _getdrive
(void), ɩɪɨɬɨɬɢɩ ɤɨɬɨɪɨɣ ɧɚɯɨɞɢɬɫɹ ɜ direct.h.
ȼɫɟ ɞɢɫɤɢ ɜ ɫɢɫɬɟɦɟ ɧɭɦɟɪɭɸɬɫɹ ɩɨ ɜɨɪɹɞɤɭ: ɞɢɫɤ Ⱥ ɢɦɟɟɬ ɧɨɦɟɪ 1, ɞɢɫɤ ȼ –
ɧɨɦɟɪ 2 ɢ ɬ. ɞ.
ɉɪɢɦɟɪ 3.7. ɑɬɟɧɢɟ ɧɨɦɟɪɚ ɞɢɫɤɚ.
#include <stdio.h>
#include <direct.h>
#include <locale.h>
int main(void) {
setlocale(LC_ALL, "RUS");
printf("Ɍɟɤɭɳɢɣ ɞɢɫɤ: %d.", _getdrive ()); return 0;
}
Ɏɭɧɤɰɢɹ int _chdrive(int drivenum), ɩɪɨɬɨɬɢɩ ɤɨɬɨɪɨɣ ɨɩɢɫɚɧ ɜ
direct.h, ɢɡɦɟɧɹɟɬ ɬɟɤɭɳɢɣ ɞɢɫɤ ɧɚ ɧɨɜɵɣ, ɭɤɚɡɚɧɧɵɣ
ɚɪɝɭɦɟɧɬɨɦ
drivenum, ɝɞɟ ɞɢɫɤ Ⱥ ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɧɨɦɟɪɭ 1, ɞɢɫɤ ȼ – ɧɨɦɟɪɭ 2 ɢ ɬɚɤ ɞɚɥɟɟ.
Ɏɭɧɤɰɢɹ _chdrive() ɜɨɡɜɪɚɳɚɟɬ 0 ɜ ɫɥɭɱɚɟ ɭɫɩɟɲɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɢ -1 ɜ
ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ.
ɉɪɢɦɟɪ 3.8. ɂɡɦɟɧɟɧɢɟ ɬɟɤɭɳɟɝɨ ɞɢɫɤɚ.
#include <stdio.h>
#include <direct.h>
#include <locale.h>
int main(void) {
int res;
setlocale(LC_ALL, "RUS");
printf("Ɂɚɞɚɟɦ ɧɨɜɵɣ ɞɢɫɤ ");
res = _chdrive (3); /* ɩɟɪɟɯɨɞ ɧɚ ɞɢɫɤ ɋ */
if (res == 0)
printf("Ɍɟɤɭɳɢɣ ɞɢɫɤ: %d.", _getdrive ());
else printf("Ɉɲɢɛɤɚ!!!");
84
return 0;
}
ɉɨɥɭɱɢɬɶ ɫɜɟɞɟɧɢɹ ɨ ɞɢɫɤɟ ɜ Windows ɦɨɠɧɨ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɮɭɧɤɰɢɢ
DeviceIoControl, ɩɪɨɬɨɬɢɩ ɤɨɬɨɪɨɣ ɧɚɯɨɞɢɬɫɹ ɜ ɮɚɣɥɟ winioctl.h.
ɋɢɧɬɚɤɫɢɫ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ DeviceIoControl ɫɥɟɞɭɸɳɢɣ [7]:
BOOL DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped
);
Ɏɨɪɦɚɥɶɧɵɟ ɩɚɪɚɦɟɬɪɵ ɮɭɧɤɰɢɢ DeviceIoControl:
hDevice (ɜɯɨɞɧɨɣ) – ɨɩɢɫɚɬɟɥɶ (descriptor) ɭɫɬɪɨɣɫɬɜɚ, ɞɥɹ ɤɨɬɨɪɨɝɨ ɜɵ-
ɩɨɥɧɹɟɬɫɹ ɨɩɟɪɚɰɢɹ. ɍɫɬɪɨɣɫɬɜɨɦ ɦɨɠɟɬ ɛɵɬɶ ɬɨɦ, ɤɚɬɚɥɨɝ, ɮɚɣɥ ɢɥɢ ɩɨɬɨɤ.
Ⱦɥɹ ɩɨɥɭɱɟɧɢɹ ɨɩɢɫɚɬɟɥɹ ɭɫɬɪɨɣɫɬɜɚ,
ɢɫɩɨɥɶɡɭɣɬɟ
ɮɭɧɤɰɢɸ CreateFile;
dwIoControlCode (ɜɯɨɞɧɨɣ) – ɭɩɪɚɜɥɹɸɳɢɣ ɤɨɞ ɞɥɹ ɨɩɟɪɚɰɢɢ, ɤɨɬɨ-
ɪɵɣ ɢɞɟɧɬɢɮɢɰɢɪɭɟɬ ɤɨɧɤɪɟɬɧɭɸ ɨɩɟɪɚɰɢɸ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɢ ɬɢɩ ɭɫɬɪɨɣɫɬɜɚ,
ɞɥɹ ɤɨɬɨɪɨɝɨ ɨɧɚ ɛɭɞɟɬ ɨɫɭɳɟɫɬɜɥɹɬɶɫɹ. Ⱦɨɤɭɦɟɧɬɚɰɢɹ ɞɥɹ ɤɚɠɞɨɝɨ ɭɩɪɚɜɥɹɸɳɟɝɨ ɤɨɞɚ ɪɚɫɫɦɚɬɪɢɜɚɟɬ ɞɟɬɚɥɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɩɚɪɚɦɟɬɪɨɜ lpInBuffer,
nInBufferSize, lpOutBuffer ɢ nOutBufferSize;
lpInBuffer (ɜɯɨɞɧɨɣ) – ɭɤɚɡɚɬɟɥɶ ɧɚ ɛɭɮɟɪ ɜɜɨɞɚ ɞɚɧɧɵɯ, ɫɨɞɟɪɠɚɳɢɣ
ɞɚɧɧɵɟ, ɧɟɨɛɯɨɞɢɦɵɟ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɨɩɟɪɚɰɢɢ
. Ɏɨɪɦɚɬ ɷɬɢɯ ɞɚɧɧɵɯ ɡɚɜɢɫɢɬ
ɨɬ ɡɧɚɱɟɧɢɹ ɩɚɪɚɦɟɬɪɚ dwIoControlCode, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɩɭɫɬɵɦ (ɪɚɜɟɧ NULL), ɟɫɥɢ dwIoControlCode ɨɩɪɟɞɟɥɹɟɬ ɨɩɟɪɚɰɢɸ, ɧɟ ɬɪɟɛɭɸɳɟɣ
ɜɜɨɞɚ ɞɚɧɧɵɯ;nInBufferSize (ɜɯɨɞɧɨɣ) – ɡɚɞɚɟɬ ɪɚɡɦɟɪ ɛɭɮɟɪɚ ɜɜɨɞɚ ɞɚɧɧɵɯ ɜ ɛɚɣɬɚɯ;
lpOutBuffer (ɜɵɯɨɞɧɨɣ) – ɭɤɚɡɚɬɟɥɶ ɧɚ ɛɭɮɟɪ ɜɵɜɨɞɚ ɞɚɧɧɵɯ, ɤɨɬɨɪɵɣ
ɞɨɥɠɟɧ ɩɨɥɭɱɢɬɶ ɞɚɧɧɵɟ, ɜɨɡɜɪɚɳɟɧɧɵɟ ɨɩɟɪɚɰɢɟɣ. Ɏɨɪɦɚɬ ɷɬɢɯ ɞɚɧɧɵɯ ɡɚɜɢ-
ɨɬ ɡɧɚɱɟɧɢɹ ɩɚɪɚɦɟɬɪɚ dwIoControlCode. ɗɬɨɬ ɩɚɪɚɦɟɬɪ ɦɨɠɟɬ ɛɵɬɶ ɪɚ-
ɫɢɬ
ɜɟɧ NULL, ɟɫɥɢ dwIoControlCode ɨɩɪɟɞɟɥɹɟɬ ɨɩɟɪɚɰɢɸ, ɤɨɬɨɪɚɹ ɧɟ ɜɨɡɜɪɚɳɚɟɬ ɞɚɧɧɵɟ;
nOutBufferSize (ɜɯɨɞɧɨɣ) – ɪɚɡɦɟɪ ɛɭɮɟɪɚ ɜɵɜɨɞɚ ɞɚɧɧɵɯ ɜ ɛɚɣɬɚɯ;
lpBytesReturned (ɜɵɯɨɞɧɨɣ) – ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɟɦɟɧɧɭɸ, ɤɨɬɨɪɚɹ ɩɨ-
ɥɭɱɚɟɬ ɪɚɡɦɟɪ ɞɚɧɧɵɯ, ɫɨɯɪɚɧɟɧɧɵɯ ɜ ɛɭɮɟɪɟ ɜɵɜɨɞɚ ɞɚɧɧɵɯ, ɜ ɛɚɣɬɚɯ. ȿɫɥɢ
ɛɭɮɟɪ ɜɵɜɨɞɚ ɞɚɧɧɵɯ ɹɜɥɹɟɬɫɹ
ɫɥɢɲɤɨɦ
ɦɚɥɟɧɶɤɢɦ, ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɤɚɤɢɟɥɢɛɨ ɞɚɧɧɵɟ, ɜɵɡɨɜ ɡɚɜɟɪɲɚɟɬɫɹ ɨɲɢɛɤɨɣ, GetLastError ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ ERROR_INSUFFICIENT_BUFFER, ɚ ɩɚɪɚɦɟɬɪ lpBytesReturned ɪɚɜɟɧ
ɧɭɥɸ. ȿɫɥɢ ɛɭɮɟɪ ɜɵɜɨɞɚ ɞɚɧɧɵɯ ɢɦɟɟɬ ɧɟɞɨɫɬɚɬɨɱɧɵɣ ɨɛɴɟɦ, ɱɬɨɛɵ ɜɦɟɫɬɢɬɶ
ɜɫɟ ɞɚɧɧɵɟ, ɧɨ ɦɨɠɟɬ ɜɦɟɫɬɢɬɶ ɧɟɤɨɬɨɪɵɟ ɜɜɨɞɢɦɵɟ ɞɚɧɧɵɟ, ɧɟɤɨɬɨɪɵɟ ɞɪɚɣɜɟɪɵ ɜɨɡɜɪɚɬɹɬ ɫɬɨɥɶɤɨ ɞɚɧɧɵɯ, ɫɤɨɥɶɤɨ ɢɯ ɜɦɟɫɬɢɥɨɫɶ. ȼ ɷɬɨɣ ɫɢɬɭɚɰɢɢ ɜɵɡɨɜ
85
ɡɚɜɟɪɲɚɟɬɫɹ ɨɲɢɛɤɨɣ, ɮɭɧɤɰɢɹ GetLastError ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ
ERROR_MORE_DATA, ɚ ɩɚɪɚɦɟɬɪ lpBytesReturned ɭɤɚɡɵɜɚɟɬ ɨɛɴɟɦ ɩɨɥɭ-
ɱɟɧɧɵɯ ɞɚɧɧɵɯ. ȼɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɞɨɥɠɧɨ ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ DeviceIoControl ɫɧɨɜɚ ɫ ɬɨɣ ɠɟ ɫɚɦɨɣ ɨɩɟɪɚɰɢɟɣ, ɨɩɪɟɞɟɥɹɹ ɧɨɜɭɸ ɬɨɱɤɭ ɨɬɫɱɟɬɚ;
lpOverlapped (ɜɯɨɞɧɨɣ) – ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɭɤɬɭɪɭ OVERLAPPED. ȿɫɥɢ
ɩɚɪɚɦɟɬɪ lpOverlapped ɪɚɜɟɧ NULL, lpBytesReturned ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɪɚɜɧɵɦ NULL. Ⱦɚɠɟ ɜ ɫɥɭɱɚɹɯ, ɤɨɝɞɚ ɨɩɟɪɚɰɢɹ ɧɟ
ɜɨɡɜɪɚɳɚɟɬ ɧɢɤɚɤɢɯ ɜɵɯɨɞɧɵɯ
ɞɚɧɧɵɯ, ɢ lpOutBuffer=NULL, ɮɭɧɤɰɢɹ DeviceIoControl ɢɫɩɨɥɶɡɭɟɬ
lpBytesReturned. ɉɨɫɥɟ ɬɚɤɨɣ ɨɩɟɪɚɰɢɢ, ɡɧɚɱɟɧɢɟ lpBytesReturned ɧɟ
ɢɦɟɟɬ ɫɦɵɫɥɚ. ȿɫɥɢ ɩɚɪɚɦɟɬɪ lpOverlapped ɧɟ ɪɚɜɟɧ NULL, lpBytesRe-
turned ɦɨɠɟɬ ɛɵɬɶ ɪɚɜɟɧ NULL. ȿɫɥɢ ɷɬɨɬ ɩɚɪɚɦɟɬɪ ɧɟ ɪɚɜɟɧ NULL, ɢ ɨɩɟɪɚɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɞɚɧɧɵɟ, ɩɚɪɚɦɟɬɪ lpBytesReturned ɧɟ ɛɭɞɟɬ ɢɦɟɬɶ ɫɦɵɫɥɚ
ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɚɫɢɧɯɪɨɧɧɚɹ ɨɩɟɪɚɰɢɹ
ɧɟ ɡɚɜɟɪɲɢɥɚɫɶ. ɑɬɨɛɵ ɢɡɜɥɟɱɶ ɢɧɮɨɪɦɚɰɢɸ ɨ ɱɢɫɥɟ ɜɨɡɜɪɚɳɚɟɦɵɯ ɞɚɧɧɵɯ, ɜɵɡɨɜɢɬɟ ɮɭɧɤɰɢɸ GetOver-
lappedResult. ȿɫɥɢ hDevice ɫɜɹɡɚɧ ɫ ɩɨɪɬɨɦ ɡɚɜɟɪɲɟɧɢɹ ɜɜɨɞɚ-ɜɵɜɨɞɚ
ɞɚɧɧɵɯ (I/O), ȼɵ ɦɨɠɟɬɟ ɢɡɜɥɟɱɶ ɱɢɫɥɨ ɜɨɡɜɪɚɳɚɟɦɵɯ ɞɚɧɧɵɯ ɩɪɢ ɩɨɦɨɳɢ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ GetQueuedCompletionStatus. ȿɫɥɢ ɩɚɪɚɦɟɬɪ hDevice
ɩɨɥɭɱɟɧ ɛɟɡ ɨɩɪɟɞɟɥɟɧɢɹ FILE_FLAG_OVERLAPPED, ɩɚɪɚɦɟɬɪ lpOver-
lapped ɢɝɧɨɪɢɪɭɟɬɫɹ. ȿɫɥɢ ɩɚɪɚɦɟɬɪ hDevice ɨɬɤɪɵɜɚɥɫɹ ɫ ɮɥɚɝɨɦ
FILE_FLAG_OVERLAPPED,
ɨɩɟɪɚɰɢɹ ɜɵɩɨɥɧɹɟɬɫɹ ɤɚɤ ɩɟɪɟɤɪɵɜɚɸɳɚɹ (ɚɫɢɧɯɪɨɧɧɚɹ) ɨɩɟɪɚɰɢɹ. ȼ ɷɬɨɣ ɫɢɬɭɚɰɢɢ ɩɚɪɚɦɟɬɪ lpOverlapped ɞɨɥɠɟɧ ɭɤɚɡɚɬɶ
ɧɚ ɞɨɩɭɫɬɢɦɭɸ ɫɬɪɭɤɬɭɪɭ OVERLAPPED, ɤɨɬɨɪɚɹ ɫɨɞɟɪɠɢɬ ɨɩɢɫɚɬɟɥɶ ɨɛɴɟɤɬɚ
ɫɨɛɵɬɢɹ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ, ɮɭɧɤɰɢɹ ɡɚɜɟɪɲɚɟɬɫɹ ɨɲɢɛɤɨɣ ɧɟɩɪɟɞɫɤɚɡɭɟɦɵɦɢ ɫɩɨɫɨɛɚɦɢ.
ȼ ɚɫɢɧɯɪɨɧɧɵɯ ɨɩɟɪɚɰɢɹɯ ɮɭɧɤɰɢɹ DeviceIoControl ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ ɧɟɦɟɞɥɟɧɧɨ, ɩɪɢ ɷɬɨɦ ɨɛɴɟɤɬ ɫɨɛɵɬɢɹ ɩɨɞɚɟɬ ɫɢɝɧɚɥ, ɤɨɝɞɚ ɨɩɟɪɚɰɢɹ ɡɚɜɟɪɲɚɟɬɫɹ. ȼ
ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ, ɮɭɧɤɰɢɹ ɧɟ ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ ɞɨ ɬɟɯ ɩɨɪ,
ɩɨɤɚ ɨɩɟɪɚɰɢɹ ɧɟ ɡɚɜɟɪɲɢɬɫɹ ɢɥɢ ɧɟ ɩɪɨɢɡɨɣɞɟɬ ɨɲɢɛɤɚ.
ȿɫɥɢ ɨɩɟɪɚɰɢɹ ɡɚɜɟɪɲɟɧɚ ɭɫɩɟɲɧɨ, ɮɭɧɤɰɢɹ DeviceIoControl ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ. ȿɫɥɢ ɨɩɟɪɚɰɢɹ ɡɚɜɟɪɲɚɟɬɫɹ ɨɲɢɛɤɨɣ, De-
viceIoControl ɜɨɡɜɪɚɳɚɟɬ ɧɭɥɶ. ɑɬɨɛɵ ɩɨɥɭɱɢɬɶ ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨɛ ɨɲɢɛɤɟ, ɜɵɡɨɜɢɬɟ GetLastError.
Ɋɚɫɫɦɨɬɪɢɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɮɭɧɤɰɢɢ DeviceIoControl ɞɥɹ ɩɨɥɭɱɟɧɢɹ
ɨɫɧɨɜɧɵɯ ɩɚɪɚɦɟɬɪɨɜ
ɠɟɫɬɤɨɝɨ ɞɢɫɤɚ.
ɉɪɢɦɟɪ 3.9. ɑɬɟɧɢɟ ɩɚɪɚɦɟɬɪɨɜ ɞɢɫɤɚ.
#include <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include <locale.h>
BOOL GetDriveGeometry(DISK_GEOMETRY *pdg) {
HANDLE hDevice; // ɨɩɢɫɚɬɟɥɶ ɩɪɨɜɟɪɹɟɦɨɝɨ
// ɭɫɬɪɨɣɫɬɜɚ
BOOL bResult; // ɮɥɚɝ ɪɟɡɭɥɶɬɚɬɚ
86
DWORD junk; // ɫɛɪɚɫɵɜɚɟɦ ɪɟɡɭɥɶɬɚɬɵ
hDevice = CreateFile("\\\\.\\PhysicalDrive0",
// ɨɬɤɪɵɜɚɟɦɨɟ ɭɫɬɪɨɣɫɬɜɨ
0, // ɧɟɬ ɞɨɫɬɭɩɚ ɤ ɭɫɬɪɨɣɫɬɜɭ
FILE_SHARE_READ | // ɪɟɠɢɦ ɫɨɜɦɟɫɬɧɨɝɨ ɞɨɫɬɭɩɚ
FILE_SHARE_WRITE,
NULL, // ɚɬɪɢɛɭɬɵ ɛɟɡɨɩɚɫɧɨɫɬɢ ɩɨ ɭɦɨɥɱɚɧɢɸ
OPEN_EXISTING, // ɪɚɫɩɨɥɨɠɟɧɢɟ
0, // ɚɬɪɢɛɭɬɵ ɮɚɣɥɚ
NULL); // ɧɟ ɤɨɩɢɪɨɜɚɬɶ ɚɬɪɢɛɭɬɵ ɮɚɣɥɚ
setlocale(LC_ALL, "RUS");
if (hDevice == INVALID_HANDLE_VALUE)
// ɧɟɜɨɡɦɨɠɧɨ ɨɬɤɪɵɬɶ ɭɫɬɪɨɣɫɬɜɨ
return (FALSE);
bResult = DeviceIoControl(hDevice,
// ɡɚɩɪɨɲɟɧɧɨɟ ɭɫɬɪɨɣɫɬɜɨ
IOCTL_DISK_GET_DRIVE_GEOMETRY, // ɨɩɟɪɚɰɢɹ
NULL, 0,
// ɛɭɮɟɪɚ ɜɜɨɞɚ ɧɟɬ
pdg, sizeof(*pdg), // ɛɭɮɟɪ ɜɵɜɨɞɚ
&junk, // ɜɨɡɜɪɚɳɟɧɨ ɛɚɣɬɨɜ
// ɫɢɧɯɪɨɧɢɡɚɰɢɹ ɜɜɨɞɚ/ɜɵɜɨɞɚ (I/O)
(LPOVERLAPPED) NULL);
CloseHandle(hDevice);
return (bResult);
}
int main(int argc, char *argv[]) {
DISK_GEOMETRY pdg; // ɫɜɟɞɟɧɢɹ ɨ ɞɢɫɤɟ
BOOL bResult; // ɮɥɚɝ ɨɛɳɢɯ ɪɟɡɭɥɶɬɚɬɨɜ
ULONGLONG DiskSize; // ɪɚɡɦɟɪ ɞɢɫɤɚ, ɜ ɛɚɣɬɚɯ bResult =
GetDriveGeometry (&pdg);
if (bResult) {
printf("napaMempbi ɞɢɫɤɚ \n");
printf("ɐɢɥɢɞɪɨɜ = %I64d\n", pdg.Cylinders);
printf("Ⱦɨɪɨɠɟɤ ɜ ɰɢɥɢɧɞɪɟ = %ld\n",
(ULONG) pdg.TracksPerCylinder);
printf("ɋɟɤɬɨɪɨɜ ɜ ɞɨɪɨɠɤɟ = %ld\n",
(ULONG) pdg.SectorsPerTrack);
printf("Ȼɚɣɬɨɜ ɫɟɤɬɨɪɟ = %ld\n",
(ULONG) pdg.BytesPerSector);
// Ɋɚɫɫɱɢɬɵɜɚɟɦ ɨɛɴɟɦ ɞɢɫɤɚ
DiskSize = pdg.Cylinders.QuadPart *
(ULONG)pdg.TracksPerCylinder *
(ULONG)pdg.SectorsPerTrack *
(ULONG)pdg.BytesPerSector;
87
printf("Ɉɛɴɟɦ ɞɢɫɤɚ = %I64d (Ȼɚɣɬ) = %I64d (Gb)\n",
DiskSize, DiskSize/(1024*1024*1024)); }
else printf ("GetDriveGeometry – ɨɲɢɛɤɚ: %ld.\n",
GetLastError ());
return ((int)bResult); }
ȼɵɩɨɥɧɢɬɟ ɷɬɨɬ ɩɪɢɦɟɪ ɢ ɩɨɥɭɱɢɬɟ ɫɜɟɞɟɧɢɹ ɨ ɞɢɫɤɚɯ ȼɚɲɟɝɨ ɤɨɦɩɶɸɬɟ-
ɪɚ. ɉɪɨɜɟɪɶɬɟ, ɜɟɪɧɵ ɥɢ ɞɚɧɧɵɟ, ɤɨɬɨɪɵɟ ɜɵɞɚɥɚ ɩɪɨɝɪɚɦɦɚ.
3.2.2. Ɋɚɛɨɬɚ ɫ ɤɚɬɚɥɨɝɚɦɢ
Ʉɚɬɚɥɨɝ – ɷɬɨ ɫɪɟɞɫɬɜɨ ɨɪɝɚɧɢɡɚɰɢɢ ɮɚɣɥɨɜ ɧɚ ɥɨɝɢɱɟɫɤɨɦ ɭɪɨɜɧɟ. Ɉɝɨɜɨɪɢɦɫɹ ɫɪɚɡɭ, ɱɬɨ ɤɚɬɚɥɨɝ – ɷɬɨ ɫɩɟɰɢɚɥɶɧɵɣ ɮɚɣɥ, ɯɪɚɧɹɳɢɣ ɫɜɟɞɟɧɢɹ ɨ ɞɪɭɝɢɯ
ɮɚɣɥɚɯ.
Ʉɚɬɚɥɨɝɢ ɦɨɝɭɬ ɢɦɟɬɶ ɪɚɡɥɢɱɧɵɟ ɪɚɡɦɟɪɵ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɨɛɴɟɦɚ ɞɢɫɤɚ
ɢ ɫɩɨɫɨɛɚ ɟɝɨ ɪɚɡɛɢɟɧɢɹ ɧɚ ɪɚɡɞɟɥɵ. ȼ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɪɚɡɛɢɟɧɢɹ ɧɚ ɪɚɡɞɟɥɵ
ɮɢɤɫɢɪɨɜɚɧɧɵɣ ɞɢɫɤ ɦɨɠɟɬ ɢɦɟɬɶ ɪɚɡɥɢɱɧɵɟ ɪɚɡɦɟɪɵ ɤɚɬɚɥɨɝɚ
ɢ ɧɨɦɟɪ
ɧɚɱɚɥɶɧɨɝɨ ɫɟɤɬɨɪɚ.
Ʉɚɠɞɵɣ ɞɢɫɤ ɢɦɟɟɬ ɨɞɢɧ ɤɨɪɧɟɜɨɣ ɤɚɬɚɥɨɝ, ɜɧɭɬɪɢ ɤɨɬɨɪɨɝɨ «ɜɥɨɠɟɧɵ»
ɜɫɟ ɨɫɬɚɥɶɧɵɟ ɤɚɬɚɥɨɝɢ (ɩɨɞɤɚɬɚɥɨɝɢ). Ʉɨɪɧɟɜɨɣ ɤɚɬɚɥɨɝ ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ
ɷɥɟɦɟɧɬɵ, ɭɤɚɡɵɜɚɸɳɢɟ ɧɚ ɩɨɞɤɚɬɚɥɨɝɢ, ɤɨɬɨɪɵɟ, ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ, ɦɨɝɭɬ ɫɨɞɟɪɠɚɬɶ ɫɫɵɥɤɢ ɧɚ ɞɪɭɝɢɟ ɩɨɞɤɚɬɚɥɨɝɢ, ɨɛɪɚɡɭɹ ɞɪɟɜɨɜɢɞɧɭɸ ɫɬɪɭɤɬɭɪɭ ɤɚɬɚɥɨɝɨɜ. Ʉɨɪɧɟɜɨɣ ɤɚɬɚɥɨɝ ɜɫɟɝɞɚ ɪɚɫɩɨɥɨɠɟɧ ɜ ɨɩɪɟɞɟɥɟɧɧɵɯ ɫɟɤɬɨɪɚɯ ɞɢɫɤɚ, ɚ
ɩɨɞɤɚɬɚɥɨɝɢ
ɯɪɚɧɹɬɫɹ ɤɚɤ ɨɛɵɱɧɵɟ ɞɢɫɤɨɜɵɟ ɮɚɣɥɵ, ɢ ɦɨɝɭɬ ɛɵɬɶ ɪɚɫɩɨɥɨɠɟ-
ɧɵ ɜ ɥɸɛɨɦ ɦɟɫɬɟ ɞɢɫɤɚ.
ȼɫɟ ɢɡɦɟɧɟɧɢɹ ɜ ɤɨɪɧɟɜɨɦ ɤɚɬɚɥɨɝɟ ɩɪɨɢɡɜɨɞɹɬɫɹ ɜ ɯɨɞɟ ɮɚɣɥɨɜɵɯ ɨɩɟɪɚɰɢɣ ɢɥɢ ɫ ɩɨɦɨɳɶɸ ɫɩɟɰɢɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ. Ɉɞɧɚɤɨ
ɦɨɠɧɨ ɪɚɛɨɬɚɬɶ ɫ ɤɚɬɚɥɨɝɨɦ ɢ ɧɚɩɪɹɦɭɸ.
ɉɪɨɝɪɚɦɦɚ ɦɨɠɟɬ ɫɨɡɞɚɜɚɬɶ ɢɥɢ ɭɞɚɥɹɬɶ ɤɚɬɚɥɨɝɢ ɢ ɩɨɞɤɚɬɚɥɨɝɢ, ɩɪɢ ɜɵɩɨɥɧɟɧɢɢ
ɨɩɪɟɞɟɥɟɧɧɵɯ ɭɫɥɨɜɢɣ. Ⱦɥɹ ɫɨɡɞɚɧɢɹ ɩɨɞɤɚɬɚɥɨɝɚ ɧɟɨɛɯɨɞɢɦɨ, ɱɬɨɛɵ ɛɵɥɨ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɫɜɨɛɨɞɧɨɟ ɦɟɫɬɨ ɜ ɤɨɪɧɟɜɨɦ ɤɚɬɚɥɨɝɟ. Ⱦɥɹ ɭɞɚɥɟɧɢɹ
ɩɨɞɤɚɬɚɥɨɝɚ ɧɟɨɛɯɨɞɢɦɨ, ɱɬɨɛɵ ɨɧ ɧɟ ɫɨɞɟɪɠɚɥ ɮɚɣɥɨɜ ɢɥɢ ɫɫɵɥɨɤ ɧɚ ɞɪɭɝɢɟ
ɩɨɞɤɚɬɚɥɨɝɢ. Ʉɪɨɦɟ ɬɨɝɨ, ȼɵ ɧɟ ɦɨɠɟɬɟ ɭɞɚɥɢɬɶ ɩɨɞɤɚɬɚɥɨɝ, ɤɨɬɨɪɵɣ ɹɜɥɹɟɬɫɹ
ȼɚɲɢɦ ɬɟɤɭɳɢɦ ɤɚɬɚɥɨɝɨɦ. Ɉɫɨɛɨ ɨɬɦɟɬɢɦ, ɱɬɨ ɤɨɪɧɟɜɨɣ ɤɚɬɚɥɨɝ ɭɞɚɥɢɬɶ ɧɟɜɨɡɦɨɠɧɨ
.
ɋɨɡɞɚɧɢɟ ɤɚɬɚɥɨɝɚ (ɩɨɞɤɚɬɚɥɨɝɚ) ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɮɭɧɤɰɢɟɣ mkdir, ɩɪɨɬɨ-
ɬɢɩ ɤɨɬɨɪɨɣ ɧɚɯɨɞɢɬɫɹ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ dir.h:
int mkdir(const char *path);
ɝɞɟ path – ɩɨɥɧɵɣ ɩɭɬɶ ɤ ɤɚɬɚɥɨɝɭ.
ɉɪɢ ɭɫɩɟɲɧɨɦ ɡɚɜɟɪɲɟɧɢɢ mkdir ɜɨɡɜɪɚɳɚɟɬ 0. ɉɪɢ ɜɨɡɧɢɤɧɨɜɟɧɢɢ
ɨɲɢɛɤɢ ɮɭɧɤɰɢɹ mkdir ɜɨɡɜɪɚɳɚɟɬ -1 ɢ ɩɟɪɟɞɚɟɬ ɜ ɝɥɨɛɚɥɶɧɭɸ ɩɟɪɟɦɟɧɧɭɸ
errno ɤɨɞ ɨɲɢɛɤɢ: EACCES (ɞɨɫɬɭɩ ɡɚɩɪɟɳɟɧ), ɢɥɢ ENOENT (ɮɚɣɥ ɢɥɢ ɤɚɬɚɥɨɝ ɨɬɫɭɬɫɬɜɭɟɬ).
Ɏɭɧɤɰɢɹ rmdir ɭɞɚɥɹɟɬ
ɤɚɬɚɥɨɝ, ɩɭɬɶ ɤ ɤɨɬɨɪɨɦɭ ɨɩɪɟɞɟɥɟɧ ɩɚɪɚɦɟɬɪɨɦ
path. ȿɟ ɫɢɧɬɚɤɫɢɫ:
88
int rmdir(const char *path);
ɝɞɟ path – ɩɨɥɧɵɣ ɩɭɬɶ ɤ ɤɚɬɚɥɨɝɭ.
ȼ ɫɥɭɱɚɟ ɭɫɩɟɯɚ ɮɭɧɤɰɢɹ rmdir() ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ 0. ȼ ɩɪɨɬɢɜɧɨɦ
ɫɥɭɱɚɟ ɜɨɡɜɪɚɳɚɟɬɫɹ -1, ɚ ɩɟɪɟɦɟɧɧɚɹ errno ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɪɚɜɧɨɣ
EACCESS (ɞɨɫɬɭɩ ɡɚɩɪɟɳɟɧ) ɢɥɢ ENOENT (ɧɟɫɭɳɟɫɬɜɭɸɳɢɣ ɩɭɬɶ).
Ɋɚɫɫɦɨɬɪɢɦ ɩɪɢɦɟɪ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɮɭɧɤɰɢɣ mkdir ɢ rmdir.
ɉɪɢɦɟɪ 3.10. Ɋɚɛɨɬɚ ɫ ɤɚɬɚɥɨɝɚɦɢ.
#include <dir.h>
#include <stdio.h>
#include <locale.h>
int main(void) {
int res; // Ɋɟɡɭɥɶɬɚɬ ɨɩɟɪɚɰɢɢ setlocale(LC_ALL,
"RUS");
// ɋɨɡɞɚɟɦ ɤɚɬɚɥɨɝ
res = mkdir("MyDir");
if (!res) printf("Ʉɚɬɚɥɨɝ ɫɨɡɞɚɧ \n");
else printf("ɇɟɥɶɡɹ
ɫɨɡɞɚɬɶ ɤɚɬɚɥɨɝ!");
// ɍɞɚɥɹɟɦ ɤɚɬɚɥɨɝ
res = rmdir("MyDir");
if (!res) printf("Ʉɚɬɚɥɨɝ ɭɞɚɥɟɧ \n");
else printf("ɇɟɥɶɡɹ ɭɞɚɥɢɬɶ ɤɚɬɚɥɨɝ!"); return 0;
}
ɉɪɨɱɢɬɚɬɶ ɬɟɤɭɳɢɣ ɤɚɬɚɥɨɝ ɦɨɠɧɨ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɮɭɧɤɰɢɢ
getcwd(char *dir, long len), ɤɨɬɨɪɚɹ ɤɨɩɢɪɭɟɬ ɩɨɥɧɵɣ ɩɭɬɶ ɬɟɤɭɳɟɝɨ
ɪɚɛɨɱɟɝɨ ɤɚɬɚɥɨɝɚ ɞɢɫɤɚ ɜ ɫɬɪɨɤɭ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɩɚɪɚɦɟɬɪ dir. ȿɫɥɢ
ɩɨɥɧɵɣ ɩɭɬɶ ɞɥɢɧɧɟɟ, ɱɟɦ len ɫɢɦɜɨɥɨɜ, ɬɨ ɜɨɡɧɢɤɚɟɬ ɨɲɢɛɤɚ. ɉɪɢ ɨɲɢɛɤɟ
ɮɭɧɤɰɢɹ getcwd() ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ NULL
, ɚ ɩɟɪɟɦɟɧɧɚɹ errno ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɪɚɜɧɨɣ ENODEV (ɭɫɬɪɨɣɫɬɜɨ ɧɟ ɫɭɳɟɫɬɜɭɟɬ), ENOMEM (ɧɟɞɨɫɬɚɬɨɱɧɨ ɩɚɦɹɬɢ) ɢɥɢ ERANGE (ɨɲɢɛɤɚ ɨɛɥɚɫɬɢ).
Ɏɭɧɤɰɢɹ chdir(const char* path) ɭɫɬɚɧɚɜɥɢɜɚɟɬ ɜ ɤɚɱɟɫɬɜɟ ɬɟɤɭɳɟɝɨ ɤɚɬɚɥɨɝ, ɧɚ ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɩɚɪɚɦɟɬɪ path. ɉɭɬɶ ɦɨɠɟɬ ɜɤɥɸɱɚɬɶ ɜ
ɫɟɛɹ ɢ ɫɩɟɰɢɮɢɤɚɰɢɸ ɞɢɫɤɚ. Ʉɚɬɚɥɨɝ ɞɨɥɠɟɧ ɫɭɳɟɫɬɜɨɜɚɬɶ. ȼ ɫɥɭɱɚɟ ɭɫɩɟɯɚ
ɮɭɧɤɰɢɹ chdir() ɜɨɡɜɪɚɳɚɟɬ 0. ɉɪɢ ɧɟɭɞɚɱɟ ɜɨɡɜɪɚɳɚɟɬɫɹ ɡɧɚɱɟɧɢɟ
-1, ɚ ɩɟ-
ɪɟɦɟɧɧɚɹ errno ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɜ ENOENT (ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɣ ɩɭɬɶ).
ɉɪɢɦɟɪ 3.11. ɂɡɦɟɧɟɧɢɟ ɤɚɬɚɥɨɝɚ.
#include <stdio.h>
#include <dir.h>
#include <locale.h>
#define MAXDIR 1000
int main(void) {
setlocale(LC_ALL, "RUS");
char dir[MAXDIR];
getcwd(dir, MAXDIR);
printf("Ɍɟɤɭɳɢɣ ɤɚɬɚɥɨɝ: %s \n", dir);
89
chdir ("C:\\Temp");
getcwd(dir, MAXDIR);
printf(”Hoɜɵɣ ɤɚɬɚɥɨɝ: %s", dir); return 0;
}
Ɏɭɧɤɰɢɹ int closedir(DIR *ptr) ɡɚɤɪɵɜɚɟɬ ɬɟɤɭɳɢɣ ɤɚɬɚɥɨɝ, ɜ ɫɥɭɱɚɟ ɭɫɩɟɯɚ ɜɨɡɜɪɚɳɚɟɬ 0 ɢ -1 ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ. ɉɪɢ ɧɟɭɞɚɱɟ ɩɟɪɟɦɟɧɧɚɹ errno
ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɪɚɜɧɨɣ EBADF (ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɣ ɤɚɬɚɥɨɝ).
Ɏɭɧɤɰɢɹ DIR *opendir(char *dirname) ɨɬɤɪɵɜɚɟɬ ɩɨɬɨɤ ɤɚɬɚɥɨɝɚ
ɢ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɭɤɬɭɪɭ ɬɢɩɚ DIR, ɤɨɬɨɪɚɹ ɫɨɞɟɪɠɢɬ ɢɧɮɨɪɦɚɰɢɸ
ɨ ɤɚɬɚɥɨɝɟ.
Ɏɭɧɤɰɢɹ struct dirent *readdir(DIR *ptr) ɨɬɤɪɵɜɚɟɬ ɩɨɬɨɤ
ɤɚɬɚɥɨɝɚ ɢ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ
ɫɬɪɭɤɬɭɪɭ ɬɢɩɚ DIR, ɤɨɬɨɪɚɹ ɫɨɞɟɪɠɢɬ ɢɧɮɨɪɦɚɰɢɸ ɨ ɤɚɬɚɥɨɝɟ, ɚ ɢɦɟɧɧɨ ɧɚɡɜɚɧɢɟ ɫɥɟɞɭɸɳɟɝɨ ɮɚɣɥɚ ɜ ɤɚɬɚɥɨɝɟ. Ɍ. ɨ.,
ɮɭɧɤɰɢɹ readdir ɱɢɬɚɟɬ ɨɝɥɚɜɥɟɧɢɟ ɤɚɬɚɥɨɝɚ ɩɨ ɨɞɧɨɦɭ ɮɚɣɥɭ ɡɚ ɨɞɢɧ ɪɚɡ.
Ɏɭɧɤɰɢɹ void rewinddir(DIR *ptr) ɨɫɭɳɟɫɬɜɥɹɟɬ ɜɨɡɜɪɚɳɟɧɢɟ ɜ
ɧɚɱɚɥɨ ɤɚɬɚɥɨɝɚ, ɧɚ ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ptr ɢ ɤɨɬɨɪɵɣ ɛɵɥ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨ
ɩɨɥɭɱɟɧ ɫ ɩɨɦɨɳɶɸ opendir.
ɉɪɨɬɨɬɢɩɵ ɮɭɧɤɰɢɣ closedir, opendiru,
readdir, ɨɩɢɫɚɧɵ ɜ ɮɚɣɥɟ
dirent.h.
Ɏɭɧɤɰɢɹ int getcurdir(int drive, char *dir) ɤɨɩɢɪɭɟɬ ɢɦɹ
ɬɟɤɭɳɟɝɨ ɤɚɬɚɥɨɝɚ, ɡɚɞɚɧɧɨɝɨ ɩɚɪɚɦɟɬɪɨɦ drive, ɜ ɫɬɪɨɤɭ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ dir. Ɂɧɚɱɟɧɢɟ 0 ɞɥɹ ɩɚɪɚɦɟɬɪɚ drive ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɞɢɫɤɭ ɩɨ ɭɦɨɥɱɚɧɢɸ. ɋɬɪɨɤɚ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ dir, ɞɨɥɠɧɚ ɢɦɟɬɶ ɞɥɢɧɭ ɤɚɤ ɦɢɧɢɦɭɦ
MAXDIR ɛɚɣɬ. ɉɪɨɬɨɬɢɩ ɮɭɧɤɰɢɢ getcurdir ɨɩɪɟɞɟɥɟɧ ɜ ɮɚɣɥɟ dir.h.
Ɉɫɨɛɟɧɧɨɫɬɶ ɮɭɧɤɰɢɢ: ɢɦɹ ɤɚɬɚɥɨɝɚ
ɧɟ ɫɨɞɟɪɠɢɬ ɢɦɹ ɞɢɫɤɚ ɢ ɧɚɱɚɥɶɧɵɯ ɨɛɪɚɬɧɵɯ ɧɚɤɥɨɧɧɵɯ ɱɟɪɬɨɱɟɤ. Ɏɭɧɤɰɢɹ getcurdir ɜ ɫɥɭɱɚɟ ɭɫɩɟɯɚ ɜɨɡɜɪɚɳɚɟɬ 0, ɚ ɩɪɢ ɨɲɢɛɤɟ, ɡɧɚɱɟɧɢɟ -1.
ɉɪɢɦɟɪ 3.12. ɉɨɥɭɱɟɧɢɟ ɫɜɟɞɟɧɢɣ ɨ ɬɟɤɭɳɟɦ ɤɚɬɚɥɨɝɟ.
#include <stdio.h>
#include <dir.h>
#include <locale.h>
#define MAXDIR 1000
int main(void) {
char dir[MAXDIR];
setlocale(LC_ALL, "RUS");
getcurdir(0, dir);
printf("Ɍɟɤɭɳɢɣ ɤɚɬɚɥɨɝ %s", dir);
return 0;
}
Ɏɭɧɤɰɢɹ char *_fullpath(char *fpath, const char *rpath,
int len) ɤɨɧɫɬɪɭɢɪɭɟɬ ɩɨɥɧɵɣ ɩɭɬɶ ɩɨ ɡɚɞɚɧɧɨɦɭ ɨɬɧɨɫɢɬɟɥɶɧɨɦɭ ɩɭɬɢ.
Ɉɬɧɨɫɢɬɟɥɶɧɵɣ ɩɭɬɶ ɡɚɞɚɟɬɫɹ ɩɟɪɟɦɟɧɧɨɣ rpath. ɉɨɥɧɵɣ ɩɭɬɶ ɩɨɦɟɳɚɟɬɫɹ
ɜ
ɦɚɫɫɢɜ, ɧɚ ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɩɚɪɚɦɟɬɪ fpath. Ɋɚɡɦɟɪ ɦɚɫɫɢɜɚ, ɧɚ ɤɨɬɨɪɵɣ
90
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]