Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
/DLL – ɭɤɚɡɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɞɨɥɠɟɧ ɛɵɬɶ ɫɨɡɞɚɧ DLL-ɦɨɞɭɥɶ,
/entry:DllMain – ɬɨɱɤɚ ɜɯɨɞɚ – ɮɭɧɤɰɢɹ DllMain;
/DEF – ɢɦɹ ɮɚɣɥɚ ɤɨɦɩɨɧɨɜɤɢ.
ɉɨɫɥɟ ɫɨɡɞɚɧɢɹ ɮɚɣɥɚ ɛɢɛɥɢɨɬɟɤɢ ɟɝɨ ɫɥɟɞɭɟɬ ɪɚɡɦɟɫɬɢɬɶ ɜ ɤɚɬɚɥɨɝɟ ɩɪɨɟɤɬɚ, ɫɨɡɞɚɧɧɨɝɨ ɧɚ ɹɡɵɤɟ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ.
Ⱦɚɥɟɟ ɫɥɟɞɭɟɬ ɩɨɞɤɥɸɱɢɬɶ ɫɨɡɞɚɧɧɭɸ ɧɚɦɢ ɛɢɛɥɢɨɬɟɤɭ ɤ ɩɪɨɝɪɚɦɦɟ. ɗɬɨ
ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɞɢɧɚɦɢɱɟɫɤɢ ɢ ɫɬɚɬɢɱɟɫɤɢ. ɉɪɢ ɞɢɧɚɦɢɱɟɫɤɨɦ ɩɨɞɤɥɸɱɟɧɢɢ
ɧɟɨɛɯɨɞɢɦɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɮɭɧɤɰɢɢ ɫɢɫɬɟɦɧɵɯ ɛɢɛɥɢɨɬɟɤ
ȼɚɲɟɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ:
ɜ Windows ɷɬɨ ɮɭɧɤɰɢɢ LoadLibrary (ɡɚɝɪɭɡɢɬɶ ɛɢɛɥɢɨɬɟɤɭ),
FreeLibrary (ɨɬɤɥɸɱɢɬɶ ɛɢɛɥɢɨɬɟɤɭ ɢ ɜɵɝɪɭɡɢɬɶ ɟɟ ɢɡ ɩɚɦɹɬɢ ɦɚɲɢɧɵ) ɢ
GetProcAddress (ɩɨɥɭɱɢɬɶ ɚɞɪɟɫ ɧɭɠɧɨɣ ɩɪɨɰɟɞɭɪɵ);
ɜ Linux ɷɬɨ ɮɭɧɤɰɢɢ dlopen (ɡɚɝɪɭɡɢɬɶ ɛɢɛɥɢɨɬɟɤɭ), dlclose (ɨɬ-
ɤɥɸɱɢɬɶ ɛɢɛɥɢɨɬɟɤɭ ɢ ɜɵɝɪɭɡɢɬɶ ɟɟ ɢɡ ɩɚɦɹɬɢ ɦɚɲɢɧɵ) ɢ dlsym (
ɩɨɥɭɱɢɬɶ
ɚɞɪɟɫ ɧɭɠɧɨɣ ɩɪɨɰɟɞɭɪɵ).
ɉɪɢ ɞɢɧɚɦɢɱɟɫɤɨɦ ɩɨɞɤɥɸɱɟɧɢɢ ɛɢɛɥɢɨɬɟɤɢ ɩɪɨɝɪɚɦɦɢɫɬ ɞɨɥɠɟɧ ɫɚɦ ɨɬɫɥɟɠɢɜɚɬɶ ɤɨɥɢɱɟɫɬɜɨ ɢ ɬɢɩ ɩɟɪɟɞɚɜɚɟɦɵɯ ɢ ɩɪɢɧɢɦɚɟɦɵɯ ɩɚɪɚɦɟɬɪɨɜ.
Ⱦɢɧɚɦɢɱɟɫɤɨɟ ɩɨɞɤɥɸɱɟɧɢɟ ɛɢɛɥɢɨɬɟɤ ɨɛɟɫɩɟɱɢɜɚɟɬ ɝɢɛɤɨɫɬɶ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɹ. Ɍɚɤ, ɜ ɫɥɭɱɚɟ ɨɬɫɭɬɫɬɜɢɹ ɧɭɠɧɨɣ ɛɢɛɥɢɨɬɟɤɢ ɦɨɠɧɨ ɩɪɟɞɭɫɦɨɬɪɟɬɶ
ɜɨɡɦɨɠɧɨɫɬɶ ɟɟ ɩɨɢɫɤɚ ɢɥɢ ɩɨɞɤɥɸɱɟɧɢɹ ɞɪɭɝɨɣ ɛɢɛɥɢɨɬɟɤɢ. ɇɟɞɨɫɬɚɬɤɨɦ ɞɢɧɚɦɢɱɟɫɤɨɝɨ ɫɩɨɫɨɛɚ ɩɨɞɤɥɸɱɟɧɢɹ ɛɢɛɥɢɨɬɟɤ ɹɜɥɹɟɬɫɹ ɢɡɛɵɬɨɱɧɨɫɬɶ
ɩɪɨ-
ɝɪɚɦɦɧɨɝɨ ɤɨɞɚ.
Ɋɚɫɫɦɨɬɪɢɦ ɩɨɞɤɥɸɱɟɧɢɟ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ Ⱥɫɫɟɦɛɥɟɪɚ ɜ ɩɪɨɟɤɬɚɯ ɋɢ/ɋ++. ȼ ɫɨɫɬɚɜ ɛɢɛɥɢɨɬɟɤɢ ɜɤɥɸɱɢɦ ɩɪɨɰɟɞɭɪɭ sum, ɫɨɡɞɚɧɧɭɸ ɧɚɦɢ
ɪɚɧɟɟ.
ɉɪɢɦɟɪ 2.58. Ʉɨɞ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ.
.386
.MODEL FLAT
PUBLIC asmsum
.DATA
.CODE
DllMain proc hInstDLL:DWORD, reason:DWORD,
reserved1:DWORD
MOV eax, -1
RET
DllMain ENDP
asmsum PROC C, a:DWORD, b:DWORD
PUSH ebx
MOV eax,a
MOV ebx ,b
ADD eax,ebx
POP ebx
RET
asmsum ENDP
71
END DllMain
ɇɢɠɟ ɩɪɟɞɫɬɚɜɥɟɧ ɮɪɚɝɦɟɧɬ ɩɪɨɝɪɚɦɦɵ ɧɚ ɹɡɵɤɟ ɋ++, ɜ ɤɨɬɨɪɨɣ ɞɢɧɚɦɢɱɟɫɤɢ ɩɨɞɤɥɸɱɚɟɬɫɹ ɛɢɛɥɢɨɬɟɤɚ MyLib.dll ɢ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɜɵɡɨɜ ɮɭɧɤɰɢɢ
asmsum.
ɉɪɢɦɟɪ 2.59. ȼɵɡɨɜ ɮɭɧɤɰɢɢ ɢɡ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ.
// Ɉɛɴɹɜɥɹɟɦ ɩɟɪɟɦɟɧɧɵɟ
int a=1, b=2, c=0;
//ɨɩɪɟɞɟɥɹɟɦ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɪɨɰɟɞɭɪɭ typedef
int(*ProcFromDll)( int, int );
HINSTANCE hLib =
LoadLibrary(TEXT( "MyLib.DLL"));
// ɉɪɨɜɟɪɹɟɦ ɪɟɡɭɥɶɬɚɬ ɡɚɝɪɭɡɤɢ ɛɢɛɥɢɨɬɟɤɢ
if (hLib == NULL) {
// ȼɵɜɨɞɢɦ ɫɨɨɛɳɟɧɢɟ ɨ ɧɟɜɨɡɦɨɠɧɨɫɬɢ
// ɡɚɝɪɭɡɤɢ ɛɢɛɥɢɨɬɟɤɢ
return;
}
// ɉɨɥɭɱɚɟɦ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɪɨɰɟɞɭɪɭ
// ɢ ɩɪɟɨɛɪɚɡɭɟɦ ɟɝɨ ɤ ɧɭɠɧɨɦɭ ɬɢɩɭ
functionDll f =
(ProcFromDll)GetProcAddress(hLib, "asmsum");
// ɉɪɨɜɟɪɹɟɦ ɩɨɥɭɱɟɧɧɵɣ ɭɤɚɡɚɬɟɥɶ if (!f)
// ȼɵɜɨɞɢɦ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɬɫɭɬɫɬɜɢɢ ɩɪɨɰɟɞɭɪɵ
// ɜ ɛɢɛɥɢɨɬɟɤɟ
else {
c=f(a, b); // ȼɵɡɵɜɚɟɦ ɩɪɨɰɟɞɭɪɭ }
FreeLibrary(hLib); // Ɉɫɜɨɛɨɠɞɚɟɦ ɩɚɦɹɬɶ
Ⱦɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɮɭɧɤɰɢɣ ɞɢɧɚɦɢɱɟɫɤɨɝɨ ɩɨɞɤɥɸɱɟɧɢɹ dll-ɛɢɛɥɢɨɬɟɤ ɢ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɯ ɬɢɩɨɜ ɧɭɠɧɨ ɜ ɩɪɨɟɤɬ ɧɚ ɋ ɢɥɢ ɋ++ ɜɤɥɸɱɢɬɶ ɡɚɝɨɥɨɜɨɱɧɵɣ
ɮɚɣɥ windows.h.
ȼ ɩɪɨɝɪɚɦɦɟ, ɧɚɩɢɫɚɧɧɨɣ ɧɚ ɹɡɵɤɟ ɜɵɫɨɤɨɝɨ
ɭɪɨɜɧɹ
, ɫɥɟɞɭɟɬ ɩɨɥɭɱɢɬɶ
ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɪɨɰɟɞɭɪɭ ɢɡ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɢ. ɋɨɡɞɚɧɧɚɹ ɧɚɦɢ ɩɪɨɰɟɞɭɪɚ ɩɪɢɧɢɦɚɟɬ ɞɜɚ ɩɚɪɚɦɟɬɪɚ, ɩɨɷɬɨɦɭ ɩɪɢ ɜɵɡɨɜɟ ɦɵ ɞɨɥɠɧɵ ɷɬɨ ɭɤɚɡɚɬɶ:
typedef int(*ProcFromDll)( int, int );
1. Ʉɚɤɢɟ ɫɢɦɜɨɥɵ ɦɨɝɭɬ ɫɨɞɟɪɠɚɬɶ ɢɞɟɧɬɢɮɢɤɚɬɨɪɵ ɹɡɵɤɚ ɋɢ?
2. Ʉɚɤɢɟ ɫɢɦɜɨɥɵ ɧɟɥɶɡɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɢɞɟɧɬɢɮɢɤɚɬɨɪɚɯ ɹɡɵɤɚ ɋɢ?
3. Ȼɚɡɨɜɵɟ ɬɢɩɵ ɞɚɧɧɵɯ ɋɢ.
4. Ɋɚɫɲɢɪɟɧɢɟ ɛɚɡɨɜɵɯ ɬɢɩɨɜ ɋɢ ɫ ɩɨɦɨɳɶɸ ɤɜɚɥɢɮɢɤɚɬɨɪɨɜ.
5. Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɵɯ ɢ ɤɨɧɫɬɚɧɬ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ.
6. Ɉɩɟɪɚɰɢɢ ɹɡɵɤɚ ɋɢ. Ɉɫɨɛɟɧɧɨɫɬɢ ɩɪɢɦɟɧɟɧɢɹ ɨɩɟɪɚɰɢɢ ɩɪɢɫɜɚɢɜɚɧɢɹ ɋɢ.
72
2.4. Ʉɨɧɬɪɨɥɶɧɵɟ ɜɨɩɪɨɫɵ ɤ ɪɚɡɞɟɥɭ 2
7. Ɉɩɟɪɚɰɢɢ ɢɧɤɪɟɦɟɧɬɚ ɢ ɞɟɤɪɟɦɟɧɬɚ. ɉɪɚɜɢɥɚ ɢ ɨɫɨɛɟɧɧɨɫɬɢ ɩɪɢɦɟɧɟ-
ɧɢɹ.
8. ɍɤɚɡɚɬɟɥɢ ɜ ɋɢ. ɉɪɚɜɢɥɚ ɨɛɴɹɜɥɟɧɢɹ ɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ.
9. Ɇɚɫɫɢɜɵ ɜ ɋɢ. Ɉɛɴɹɜɥɟɧɢɟ ɢ ɧɚɱɚɥɶɧɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ.
10. ɋɜɹɡɶ ɦɚɫɫɢɜɨɜ ɢ ɭɤɚɡɚɬɟɥɟɣ ɜ ɋɢ.
11. ɋɬɪɨɤɢ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ. Ɉɫɧɨɜɧɵɟ ɨɩɟɪɚɰɢɢ ɫɨ ɫɬɪɨɤɚɦɢ.
12. ɍɫɥɨɜɧɵɣ ɨɩɟɪɚɬɨɪ if. ɋɢɧɬɚɤɫɢɫ. ɉɪɢɧɰɢɩ ɪɚɛɨɬɵ. Ʉɚɤ ɭɤɚɡɚɬɶ ɜ
ɭɫɥɨɜɢɢ ɧɟɫɤɨɥɶɤɨ ɚɥɶɬɟɪɧɚɬɢɜ?
13. Ɉɩɟɪɚɬɨɪ ɜɚɪɢɚɧɬɚ switch. ɋɢɧɬɚɤɫɢɫ. ɉɪɢɧɰɢɩ ɪɚɛɨɬɵ. Ʉɚɤ ɭɤɚɡɚɬɶ ɜ
ɪɚɡɞɟɥɟ case ɧɟɫɤɨɥɶɤɨ ɚɥɶɬɟɪɧɚɬɢɜ?
14. Ɉɩɟɪɚɬɨɪ ɛɟɡɭɫɥɨɜɧɨɝɨ ɩɟɪɟɯɨɞɚ goto. ɋɢɧɬɚɤɫɢɫ. ɉɪɚɜɢɥɚ ɢ ɨɫɨɛɟɧɧɨ-
ɫɬɢ ɩɪɢɦɟɧɟɧɢɹ.
15. Ɉɩɟɪɚɬɨɪ ɰɢɤɥɚ for. ɋɢɧɬɚɤɫɢɫ. Ɉɫɨɛɟɧɧɨɫɬɢ ɪɚɡɞɟɥɨɜ.
16. Ɉɩɟɪɚɬɨɪɵ ɰɢɤɥɚ while ɢ do while. ɋɢɧɬɚɤɫɢɫ. ɑɟɦ ɷɬɢ ɰɢɤɥɵ ɨɬɥɢɱɚ-
ɸɬɫɹ ɞɪɭɝ ɨɬ ɞɪɭɝɚ?
17. Ɉɩɟɪɚɬɨɪɵ break ɢ continue. ɉɪɚɜɢɥɚ ɢ ɨɫɨɛɟɧɧɨɫɬɢ
ɩɪɢɦɟɧɟɧɢɹ.
18. Ɏɭɧɤɰɢɢ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ. ɉɪɚɜɢɥɚ ɨɛɴɹɜɥɟɧɢɹ. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ
ɜ ɮɭɧɤɰɢɢ.
19. ɋɬɪɭɤɬɭɪɚ ɩɪɨɝɪɚɦɦɵ ɧɚ ɹɡɵɤɟ ɋɢ. Ƚɥɨɛɚɥɶɧɵɟ ɢ ɥɨɤɚɥɶɧɵɟ ɩɟɪɟɦɟɧ-
ɧɵɟ – ɨɫɨɛɟɧɧɨɫɬɢ ɨɛɴɹɜɥɟɧɢɹ ɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ.
20. Ⱦɢɪɟɤɬɢɜɵ ɩɪɟɩɪɨɰɟɫɫɨɪɚ ɋɢ. ɉɪɚɜɢɥɚ ɡɚɩɢɫɢ.
21. ɋɬɪɭɤɬɭɪɚ ɩɪɨɝɪɚɦɦɵ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ. Ʉɚɤɢɟ ɪɚɡɞɟɥɵ ɨɛɹɡɚɬɟɥɶɧɨ
ɞɨɥɠɧɵ ɩɪɢɫɭɬɫɬɜɨɜɚɬɶ ɜ ɩɪɨɝɪɚɦɦɟ?
22. ɋɢɧɬɚɤɫɢɫ ɤɨɦɚɧɞ Ⱥɫɫɟɦɛɥɟɪɚ.
23. Ʉɚɤɢɟ
ɬɢɩɵ ɞɚɧɧɵɯ Ⱥɫɫɟɦɛɥɟɪɚ ȼɵ ɡɧɚɟɬɟ? ɑɟɦ ɨɧɢ ɞɪɭɝ ɨɬ ɞɪɭɝɚ ɨɬ-
ɥɢɱɚɸɬɫɹ?
24. Ʉɚɤ ɨɛɴɹɜɥɹɸɬɫɹ ɩɟɪɟɦɟɧɧɵɟ ɜ Ⱥɫɫɟɦɛɥɟɪɟ?
25. Ʉɨɦɚɧɞɵ ɩɟɪɟɞɚɱɢ ɞɚɧɧɵɯ Ⱥɫɫɟɦɛɥɟɪɚ. ȼ ɱɟɦ ɫɨɫɬɨɹɬ ɨɫɨɛɟɧɧɨɫɬɢ ɢɯ
ɩɪɢɦɟɧɟɧɢɹ?
26. ɉɟɪɟɱɢɫɥɢɬɟ, ɤɚɤɢɟ ɫɩɨɫɨɛɵ ɚɞɪɟɫɚɰɢɢ ɜ Ⱥɫɫɟɦɛɥɟɪɟ ȼɵ ɡɧɚɟɬɟ? Ʉɪɚɬ-
ɤɨ ɨɯɚɪɚɤɬɟɪɢɡɭɣɬɟ ɤɚɠɞɵɣ ɜɢɞ ɚɞɪɟɫɚɰɢɢ.
27. Ⱥɪɢɮɦɟɬɢɱɟɫɤɢɟ ɨɩɟɪɚɰɢɢ Ⱥɫɫɟɦɛɥɟɪɚ. ɋɢɧɬɚɤɫɢɫ. Ɉɫɨɛɟɧɧɨɫɬɢ
ɦɟɧɟɧɢɹ.
28. Ʌɨɝɢɱɟɫɤɢɟ ɨɩɟɪɚɰɢɢ Ⱥɫɫɟɦɛɥɟɪɚ. ɋɢɧɬɚɤɫɢɫ. Ɉɫɨɛɟɧɧɨɫɬɢ ɩɪɢɦɟɧɟ-
ɧɢɹ.
29. Ʉɨɦɚɧɞɚ ɛɟɡɭɫɥɨɜɧɨɝɨ ɩɟɪɟɯɨɞɚ JMP. ɋɢɧɬɚɤɫɢɫ. Ɉɫɨɛɟɧɧɨɫɬɢ ɛɥɢɠ-
ɧɢɯ ɢ ɞɚɥɶɧɢɯ ɩɟɪɟɯɨɞɨɜ.
30. Ƚɪɭɩɩɚ ɤɨɦɚɧɞ ɭɫɥɨɜɧɵɯ ɩɟɪɟɯɨɞɨɜ JCC. Ʉɚɤ ɡɚɞɚɬɶ ɭɫɥɨɜɢɹ ɩɟɪɟɯɨɞɚ?
31. ɐɢɤɥɵ ɜ ɩɪɨɝɪɚɦɦɚɯ Ⱥɫɫɟɦɛɥɟɪɚ. Ɉɫɨɛɟɧɧɨɫɬɢ ɨɪɝɚɧɢɡɚɰɢɢ ɜɥɨɠɟɧ-
ɧɵɯ ɰɢɤɥɨɜ.
32. ɉɟɪɟɱɢɫɥɢɬɟ ɫɩɨɫɨɛɵ ɢɧɬɟɝɪɚɰɢɢ ɹɡɵɤɨɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɜɵɫɨɤɨɝɨ
ɭɪɨɜɧɹ ɫ ɦɨɞɭɥɹɦɢ Ⱥɫɫɟɦɛɥɟɪɚ
.
33. Ⱥɫɫɟɦɛɥɟɪɧɵɟ ɜɫɬɚɜɤɢ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ. ɋɢɧɬɚɤɫɢɫ. Ɉɫɨɛɟɧɧɨɫɬɢ ɪɟɚ-
ɥɢɡɚɰɢɢ ɪɚɡɞɟɥɨɜ.
ɩɪɢ-
73
34. Ɉɫɨɛɟɧɧɨɫɬɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɪɟɝɢɫɬɪɨɜ ɦɢɤɪɨɩɪɨɰɟɫɫɨɪɚ ɜ ɚɫɫɟɦɛɥɟɪ-
ɧɵɯ ɜɫɬɚɜɤɚɯ ɋɢ.
35. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɜ ɚɫɫɟɦɛɥɟɪɧɭɸ ɜɫɬɚɜɤɭ ɢɡ ɩɪɨɝɪɚɦɦɵ ɋɢ.
36. Ⱦɢɧɚɦɢɱɟɫɤɢɟ ɛɢɛɥɢɨɬɟɤɢ Ⱥɫɫɟɦɛɥɟɪɚ – ɧɚɡɧɚɱɟɧɢɟ, ɫɬɪɭɤɬɭɪɚ.
37. Ʉɚɤ ɫɤɨɦɩɢɥɢɪɨɜɚɬɶ ɢ ɩɨɞɤɥɸɱɢɬɶ ɞɢɧɚɦɢɱɟɫɤɭɸ ɛɢɛɥɢɨɬɟɤɭ Ⱥɫɫɟɦ-
ɛɥɟɪɚ ɤ ɩɪɨɝɪɚɦɦɟ ɋɢ?
74
3.ʞʟʝʒʟʏʛʛʗʟʝʑʏʜʗʔʏʞʞʏʟʏʡʜʪʤʠʟʔʓʠʡʑ
3.1. ȼɜɨɞ ɫ ɤɥɚɜɢɚɬɭɪɵ ɢ ɜɵɜɨɞ ɧɚ ɷɤɪɚɧ
Ɋɚɫɫɦɨɬɪɢɦ ɜɨɡɦɨɠɧɨɫɬɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɨɩɟɪɚɰɢɣ ɜɜɨɞɚ ɫ ɤɥɚɜɢɚɬɭɪɵ
ɢ ɜɵɜɨɞɚ ɧɚ ɷɤɪɚɧ ɜ Windows ɢ Linux ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɪɟɞɫɬɜ ɹɡɵɤɚ ɋɢ.
ȼ ɩɪɨɝɪɚɦɦɚɯ Ⱥɫɫɟɦɛɥɟɪɚ ɞɥɹ DOS ɢ Windows ɱɬɟɧɢɟ ɤɨɞɨɜ ɫɢɦɜɨɥɨɜ ɫ
ɤɥɚɜɢɚɬɭɪɵ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɱɟɪɟɡ ɮɭɧɤɰɢɸ 1 ɩɪɟɪɵɜɚɧɢɹ int 21h DOS,
ɢɥɢ ɮɭɧɤɰɢɸ 0 ɩɪɟɪɵɜɚɧɢɹ 16h BIOS. Ʉɨɞ ɧɚɠɚɬɨɣ ɤɥɚɜɢɲɢ ɛɭɞɟɬ
ɧɚɯɨɞɢɬɶɫɹ ɜ ɪɟɝɢɫɬɪɟ AL. ɋɬɪɨɤɭ ɫɢɦɜɨɥɨɜ ɦɨɠɧɨ ɩɪɨɱɢɬɚɬɶ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ
0Ah ɩɪɟɪɵɜɚɧɢɹ int 21h.
ȼ ɩɪɨɝɪɚɦɦɚɯ Ⱥɫɫɟɦɛɥɟɪɚ ɞɥɹ Linux ɞɥɹ ɜɜɨɞɚ-ɜɵɜɨɞɚ ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɪɟ-
ɪɵɜɚɧɢɟ int 80h.
Ɉɬɦɟɬɢɦ, ɱɬɨ ɩɨɫɥɟɞɧɢɟ ɜɟɪɫɢɢ Windows ɧɟ ɩɨɡɜɨɥɹɸɬ ɜɵɩɨɥɧɹɬɶ ɜɵɡɨɜ ɢ
ɨɛɪɚɛɨɬɤɭ ɩɪɟɪɵɜɚɧɢɣ ɢɡ ɩɪɨɝɪɚɦɦ ɩɨɥɶɡɨɜɚɬɟɥɹ. Ⱦɥɹ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɸɬɫɹ
ɮɭɧɤɰɢɢ ɛɢɛɥɢɨɬɟɤ Windows API [7]. ɀɟɥɚɸɳɢɟ ɦɨɝɭɬ ɨɡɧɚɤɨɦɢɬɶɫɹ ɫ ɜɜɨɞɨɦɜɵɜɨɞɨɦ
ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɜ ɥɢɬɟɪɚɬɭɪɟ [2, 6, 7].
Ʉɥɚɜɢɚɬɭɪɚ – ɫɬɚɧɞɚɪɬɧɨɟ ɭɫɬɪɨɣɫɬɜɨ ɜɜɨɞɚ ɞɚɧɧɵɯ, ɩɨɞɤɥɸɱɟɧɧɨɟ ɱɟɪɟɡ
ɤɨɧɬɪɨɥɥɟɪ ɤɥɚɜɢɚɬɭɪɵ (ɫɦ. ɪɢɫ. 1.1), ɤɨɬɨɪɨɟ ɩɨɡɜɨɥɹɟɬ ɩɟɪɟɞɚɜɚɬɶ ɜ ɤɨɦɩɶɸɬɟɪ ɤɨɞɵ ɧɚɠɚɬɵɯ ɤɥɚɜɢɲ (ɬ. ɧ. scan-ɤɨɞɵ). Ɍɚɤ, ɧɚɩɪɢɦɟɪ, ɤɨɝɞɚ ȼɵ ɧɚɠɢɦɚɟɬɟ
ɧɚ ɤɥɚɜɢɚɬɭɪɟ ɤɥɚɜɢɲɭ G, ɬɨ ɩɟɪɟɞɚɟɬɫɹ ɧɟ ɫɚɦ ɫɢɦɜɨɥ, ɚ ɟɝɨ ɤɨɞ – 47h. ɉɪɢ
ɫɱɢɬɵɜɚɧɢɢ ɩɪɨɝɪɚɦɦɚ ɞɨɥɠɧɚ ɢɞɟɧɬɢɮɢɰɢɪɨɜɚɬɶ ɤɥɚɜɢɲɢ
ɫɨɝɥɚɫɧɨ ɢɯ ɤɨɞɚɦ
(ɢɯ ɟɳɟ ɧɚɡɵɜɚɸɬ scan-ɤɨɞɚɦɢ).
Ɂɚɞɚɱɢ, ɪɟɲɚɟɦɵɟ ɤɨɧɬɪɨɥɥɟɪɨɦ ɤɥɚɜɢɚɬɭɪɵ: ɪɟɚɝɢɪɨɜɚɬɶ ɧɚ ɧɚɠɚɬɢɟ ɤɥɚɜɢɲ ɢɥɢ ɤɨɦɛɢɧɚɰɢɢ ɤɥɚɜɢɲ; ɪɟɚɝɢɪɨɜɚɬɶ ɧɚ «ɞɥɢɬɟɥɶɧɨɟ» ɧɚɠɚɬɢɟ ɧɚ ɤɥɚɜɢɲɭ, ɢ ɨɫɭɳɟɫɬɜɥɹɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
ɉɨ ɩɨɥɨɠɟɧɢɸ ɤɥɚɜɢɲ ɝɟɧɟɪɢɪɨɜɚɬɶ ɫɩɟɰɢɚɥɶɧɵɣ scan-ɤɨɞ ɤɥɚɜɢɲɢ.
ȼ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫ ɬɚɛɥɢɰɟɣ ɫɢɦɜɨɥɨɜ ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶ scan-ɤɨɞ ɤɥɚɜɢɲɢ ɜ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɟɣ ɫɢɦɜɨɥ ASCII.
Ɂɚɧɨɫɢɬɶ
ɩɚɪɭ «ɫɢɦɜɨɥ» – «scan-ɤɨɞ» ɜ ɤɥɚɜɢɚɬɭɪɧɵɣ ɛɭɮɟɪ.
Ʉɚɠɞɚɹ ɤɥɚɜɢɲɚ ɢɦɟɟɬ ɫɨɛɫɬɜɟɧɧɵɣ scan-ɤɨɞ. Ʉɪɨɦɟ ɬɨɝɨ, ɤɨɦɛɢɧɚɰɢɢ
ɤɥɚɜɢɲ ɢɦɟɸɬ ɨɬɞɟɥɶɧɵɟ scan-ɤɨɞɵ. Ɍɚɤ, ɧɚɩɪɢɦɟɪ, ɟɫɥɢ scan-ɤɨɞ ɤɥɚɜɢɲɢ
«F10» ɪɚɜɟɧ 68, ɬɨ ɤɨɞ ɬɨɣ ɠɟ ɤɥɚɜɢɲɢ ɫ ɨɞɧɨɜɪɟɦɟɧɧɨ ɧɚɠɚɬɨɣ ɤɥɚɜɢɲɟɣ
«Shift» ɛɭɞɟɬ ɪɚɜɟɧ 93, ɜ ɤɨɦɛɢɧɚɰɢɢ ɫ ɤɥɚɜɢɲɟɣ «Ctrl» – 103, ɚ ɜ ɤɨɦɛɢɧɚɰɢɢ ɫ
ɤɥɚɜɢɲɟɣ «Alt» – 113.
ɋɭɳɟɫɬɜɭɸɬ ɬ. ɧ. «ɚɥɮɚɜɢɬɧɨ-ɰɢɮɪɨɜɵɟ
»
ɢ «ɭɩɪɚɜɥɹɸɳɢɟ» ɤɥɚɜɢɲɢ. Ⱥɥɮɚɜɢɬɧɨ-ɰɢɮɪɨɜɵɟ ɤɥɚɜɢɲɢ ɝɟɧɟɪɢɪɭɸɬ scan-ɤɨɞ ɢ ASCII ɫɢɦɜɨɥɵ (ɰɢɮɪɵ ɢ
ɛɭɤɜɵ). ɍɩɪɚɜɥɹɸɳɢɟ ɤɥɚɜɢɲɢ ɝɟɧɟɪɢɪɭɸɬ ɬɨɥɶɤɨ ɪɚɫɲɢɪɟɧɧɵɣ scan-ɤɨɞ, ɚ ɜ
ɩɨɥɟ ɫɢɦɜɨɥɚ ɜɵɞɚɸɬ ɧɨɥɶ.
Ȼɥɚɝɨɞɚɪɹ ɧɚɥɢɱɢɸ scan-ɤɨɞɨɜ ɤɥɚɜɢɲ ɩɪɨɝɪɚɦɦɢɫɬ ɜɫɟɝɞɚ ɦɨɠɟɬ ɩɨɧɹɬɶ,
ɤɚɤ ɨɛɪɚɛɚɬɵɜɚɬɶ ɤɨɞ ɤɥɚɜɢɲɢ: ɜɵɜɨɞɢɬɶ ɥɢ ɫɢɦɜɨɥ ɧɚ ɷɤɪɚɧ ɢɥɢ ɜɵɩɨɥɧɹɬɶ
ɭɩɪɚɜɥɹɸɳɭɸ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɞɟɣɫɬɜɢɣ.
ɉɨɥɭɱɟɧɧɵɣ ɩɨɫɥɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ
ɜ ɤɨɧɬɪɨɥɥɟɪɟ ɤɥɚɜɢɚɬɭɪɵ ɞɜɭɯɛɚɣ-
ɬɨɜɵɣ ɤɨɞ ɩɚɪɵ «ɫɢɦɜɨɥ»-«sɫan-ɤɨɞ» ɩɨɫɵɥɚɟɬɫɹ ɜ ɤɨɥɶɰɟɜɨɣ ɛɭɮɟɪ ɜɜɨɞɚ,
75
ɞɥɹ ɫɢɧɯɪɨɧɢɡɚɰɢɢ ɜɜɨɞɚ ɞɚɧɧɵɯ ɫ ɤɥɚɜɢɚɬɭɪɵ ɢ ɩɪɢɺɦɚ ɢɯ ɜɵɩɨɥɧɹɟɦɨɣ ɩɪɨɝɪɚɦɦɨɣ. Ɉɛɴɺɦ ɤɨɥɶɰɟɜɨɝɨ ɛɭɮɟɪɚ ɧɟɛɨɥɶɲɨɣ ɢ ɨɛɵɱɧɨ ɫɨɫɬɚɜɥɹɟɬ 30 ɛɚɣɬ.
Ʉɨɥɶɰɟɜɨɣ ɛɭɮɟɪ ɨɪɝɚɧɢɡɨɜɚɧ ɩɨ ɩɪɢɧɰɢɩɭ: «ɩɟɪɜɵɦ ɡɚɩɢɫɚɧ – ɩɟɪɜɵɦ ɫɱɢɬɚɧ»
(FIFO – First Input–First Output), ɩɨɷɬɨɦɭ ɩɪɢ ɟɝɨ ɩɟɪɟɩɨɥɧɟɧɢɢ ɧɨɜɵɟ ɤɨɞɵ ɜ ɧɟɦ
ɧɟ ɫɨɯɪɚɧɹɸɬɫɹ, ɚ ɧɚɠɚɬɢɟ ɧɚ ɤɥɚɜɢɲɢ ɜɵɡɵɜɚɟɬ ɩɪɟɞɭɩɪɟɠɞɚɸɳɢɟ ɫɢɝɧɚɥɵ.
əɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɋɢ ɩɪɟɞɨɫɬɚɜɥɹɟɬ
ɩɨɥɧɵɣ ɧɚɛɨɪ ɮɭɧɤɰɢɣ ɞɥɹ
ɜɜɨɞɚ ɫ ɤɥɚɜɢɚɬɭɪɵ ɢ ɜɵɜɨɞɚ ɧɚ ɷɤɪɚɧ [5]. Ɋɚɫɫɦɨɬɪɢɦ ɢɯ ɩɨɞɪɨɛɧɨ.
Ɍɟɤɫɬ ɩɪɨɝɪɚɦɦɵ ɧɚ ɋɢ, ɢɫɩɨɥɶɡɭɸɳɟɣ ɯɨɬɹ ɛɵ ɨɞɧɭ ɮɭɧɤɰɢɸ ɛɢɛɥɢɨɬɟɤɢ ɜɜɨɞɚ-ɜɵɜɨɞɚ, ɞɨɥɠɟɧ ɫɨɞɟɪɠɚɬɶ ɜ ɧɚɱɚɥɟ ɫɬɪɨɤɭ ɩɨɞɤɥɸɱɟɧɢɹ ɡɚɝɨɥɨɜɨɱɧɨɝɨ ɮɚɣɥɚ:
#include <stdio.h>
ɉɪɨɫɬɟɣɲɢɣ ɦɟɯɚɧɢɡɦ ɜɜɨɞɚ – ɷɬɨ ɱɬɟɧɢɟ ɨɞɧɨɝɨ ɫɢɦɜɨɥɚ ɢɡ ɫɬɚɧɞɚɪɬɧɨɝɨ
ɭɫɬɪɨɣɫɬɜɚ (ɨɛɵɱɧɨ ɷɬɨ ɤɥɚɜɢɚɬɭɪɚ) ɮɭɧɤɰɢɟɣ
int getchar(void)
ɉɨɫɥɟ ɤɚɠɞɨɝɨ ɫɜɨɟɝɨ ɜɵɡɨɜɚ ɮɭɧɤɰɢɹ getchar() ɜɨɡɜɪɚɳɚɟɬ ɫɥɟɞɭɸɳɢɣ ɫɢɦɜɨɥ, ɜɜɟɞɟɧɧɵɣ ɫ ɤɥɚɜɢɚɬɭɪɵ.
ȼ ɤɚɱɟɫɬɜɟ ɩɪɢɦɟɪɚ ɪɚɫɫɦɨɬɪɢɦ ɩɪɨɝɪɚɦɦɭ, ɤɨɬɨɪɚɹ ɩɟɪɟɜɨɞɢɬ ɜɜɟɞɟɧɧɵɣ
ɫɢɦɜɨɥ ɜ ɧɢɠɧɢɣ ɪɟɝɢɫɬɪ.
ɉɪɢɦɟɪ 3.1. ȼɜɨɞ ɢ ɜɵɜɨɞ ɫɢɦɜɨɥɚ.
#include <stdio.h>
#include <ctype.h>
main() {
int ɫ;
while ((ɫ = getchar()) != EOF)
putchar(tolower(c));
return 0; }
Ɏɭɧɤɰɢɹ tolower ɨɩɪɟɞɟɥɟɧɚ ɜ <ctype.h>. Ɉɧɚ ɩɟɪɟɜɨɞɢɬ ɛɭɤɜɵ
ɜɟɪɯɧɟɝɨ ɪɟɝɢɫɬɪɚ ɜ ɛɭɤɜɵ ɧɢɠɧɟɝɨ ɪɟɝɢɫɬɪɚ, ɚ
ɨɫɬɚɥɶɧɵɟ ɫɢɦɜɨɥɵ ɜɨɡɜɪɚɳɚɟɬ
ɛɟɡ ɢɡɦɟɧɟɧɢɣ. Ɂɧɚɱɟɧɢɟ EOF – ɩɪɢɡɧɚɤ ɨɤɨɧɱɚɧɢɹ ɜɜɨɞɚ (ɨɛɵɱɧɨ EOF = -1).
Ɉɞɧɚɤɨ ɩɨɫɢɦɜɨɥɶɧɵɣ ɜɜɨɞ ɧɟ ɜɫɟɝɞɚ ɧɭɠɟɧ, ɢ ɤ ɬɨɦɭ ɠɟ ɧɟ ɜɫɟɝɞɚ ɭɞɨɛɟɧ.
ɑɚɳɟ ɧɭɠɧɨ ɜɜɨɞɢɬɶ ɦɧɨɠɟɫɬɜɨ ɪɚɡɧɨɪɨɞɧɵɯ ɞɚɧɧɵɯ, ɬɚɤɢɯ ɤɚɤ ɫɬɪɨɤɢ, ɫɢɦɜɨɥɵ ɢ ɱɢɫɥɚ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɧɚɢɛɨɥɟɟ ɭɞɨɛɧɵɦ ɢ ɭɧɢɜɟɪɫɚɥɶɧɵɦ ɹɜɥɹɟɬɫɹ
ɮɨɪɦɚɬɢɪɨɜɚɧɧɵɣ ɜɜɨɞ, ɤɨɬɨɪɵɣ ɪɟɚɥɢɡɭɟɬɫɹ ɫ
ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ scanf,
ɫɢɧɬɚɤɫɢɫ ɤɨɬɨɪɨɣ:
int scanf(char *format, ...),
ɝɞɟ format – ɫɬɪɨɤɚ ɮɨɪɦɚɬɚ.
Ɏɭɧɤɰɢɹ scanf ɱɢɬɚɟɬ ɫɢɦɜɨɥɵ ɢɡ ɫɬɚɧɞɚɪɬɧɨɝɨ ɜɯɨɞɧɨɝɨ ɩɨɬɨɤɚ
(ɧɚɩɪɢɦɟɪ, ɤɥɚɜɢɚɬɭɪɵ), ɢɧɬɟɪɩɪɟɬɢɪɭɟɬ ɢɯ ɫɨɝɥɚɫɧɨ ɫɩɟɰɢɮɢɤɚɰɢɹɦ ɫɬɪɨɤɢ
ɮɨɪɦɚɬɚ ɢ ɡɚɧɨɫɢɬ ɪɟɡɭɥɶɬɚɬɵ ɜ ɫɜɨɢ ɨɫɬɚɥɶɧɵɟ ɚɪɝɭɦɟɧɬɵ, ɜ ɤɚɱɟɫɬɜɟ ɤɨɬɨɪɵɯ
ɢɫɩɨɥɶɡɭɸɬɫɹ ɩɟɪɟɦɟɧɧɵɟ ɩɪɨɝɪɚɦɦɵ.
Ɏɭɧɤɰɢɹ scanf ɩɪɟɤɪɚɳɚɟɬ ɪɚɛɨɬɭ ɬɨɝɞɚ, ɤɨɝɞɚ ɢɫɱɟɪɩɚɧ ɮɨɪɦɚɬ ɢɥɢ
ɜɜɨɞɢɦɚɹ ɜɟɥɢɱɢɧɚ ɧɟ
ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɡɚɞɚɧɧɨɣ ɫɩɟɰɢɮɢɤɚɰɢɢ. Ɏɭɧɤɰɢɹ scanf
ɜɨɡɜɪɚɳɚɟɬ ɤɨɥɢɱɟɫɬɜɨ ɭɫɩɟɲɧɨ ɜɜɟɞɟɧɧɵɯ ɷɥɟɦɟɧɬɨɜ ɞɚɧɧɵɯ. Ʉɚɠɞɨɟ ɨɱɟɪɟɞɧɨɟ ɨɛɪɚɳɟɧɢɟ ɤ scanf ɩɪɨɞɨɥɠɚɟɬ ɜɜɨɞ ɫ ɫɢɦɜɨɥɚ, ɫɥɟɞɭɸɳɟɝɨ ɫɪɚɡɭ ɡɚ ɩɨɫɥɟɞɧɢɦ ɨɛɪɚɛɨɬɚɧɧɵɦ.
76
Ɏɨɪɦɚɬ ɫɨɞɟɪɠɢɬ ɫɩɟɰɢɮɢɤɚɰɢɢ, ɧɟɨɛɯɨɞɢɦɵɟ ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɩɪɟɨɛɪɚ-
ɡɨɜɚɧɢɹɦɢ ɜɜɨɞɚ. ȼ ɮɨɪɦɚɬ ɦɨɝɭɬ ɜɯɨɞɢɬɶ ɫɥɟɞɭɸɳɢɟ ɷɥɟɦɟɧɬɵ:
ɩɪɨɛɟɥɵ ɢɥɢ ɡɧɚɤɢ ɬɚɛɭɥɹɰɢɢ (ɢɝɧɨɪɢɪɭɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ);
ɨɛɵɱɧɵɟ ɫɢɦɜɨɥɵ (ɢɫɤɥɸɱɚɹ %), ɤɨɬɨɪɵɟ, ɤɚɤ ɨɠɢɞɚɟɬɫɹ, ɫɨɜɩɚɞɭɬ ɫ
ɨɱɟɪɟɞɧɵɦɢ ɫɢɦɜɨɥɚɦɢ, ɨɬɥɢɱɧɵɦɢ ɨɬ ɫɢɦɜɨɥɨɜ-ɪɚɡɞɟɥɢɬɟɥɟɣ ɜɯɨɞɧɨɝɨ ɩɨɬɨɤɚ;
ɫɩɟɰɢɮɢɤɚɰɢɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ, ɤɚɠɞɚɹ ɢɡ ɤɨɬɨɪɵɯ ɧɚɱɢɧɚɟɬɫɹ ɫɨ ɡɧɚɤɚ %
ɡɚɜɟɪɲɚɟɬɫɹ ɫɢɦɜɨɥɨɦ-ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ ɬɢɩɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ. Ɇɟɠɞɭ ɷɬɢɦɢ
ɢ
ɞɜɭɦɹ ɫɢɦɜɨɥɚɦɢ ɜ ɥɸɛɨɣ ɫɩɟɰɢɮɢɤɚɰɢɢ ɦɨɝɭɬ ɪɚɫɩɨɥɚɝɚɬɶɫɹ, ɩɪɢɱɟɦ ɜ ɬɨɦ
ɩɨɪɹɞɤɟ, ɤɚɤ ɨɧɢ ɡɞɟɫɶ ɭɤɚɡɚɧɵ: ɡɧɚɤ * (ɩɪɢɡɧɚɤ ɩɨɞɚɜɥɟɧɢɹ ɩɪɢɫɜɚɢɜɚɧɢɹ);
ɱɢɫɥɨ, ɨɩɪɟɞɟɥɹɸɳɟɟ ɲɢɪɢɧɭ ɩɨɥɹ; ɛɭɤɜɚ h ɢɥɢ l, ɭɤɚɡɵɜɚɸɳɚɹ ɧɚ ɪɚɡɦɟɪ
ɩɨɥɭɱɚɟɦɨɝɨ ɡɧɚɱɟɧɢɹ; ɢ ɫɢɦɜɨɥ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ (ɨ, d, x). Ʉɚɠɞɚɹ ɫɩɟɰɢɮɢɤɚɰɢɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɫɥɭɠɢɬ
ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɜɜɨɞɢɦɨɝɨ ɩɨɥɹ.
Ɉɛɵɱɧɨ ɪɟɡɭɥɶɬɚɬ ɩɨɦɟɳɚɟɬɫɹ ɜ ɤɚɤɭɸ-ɥɢɛɨ ɩɟɪɟɦɟɧɧɭɸ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɚɪɝɭɦɟɧɬ. Ɉɞɧɚɤɨ ɟɫɥɢ ɜ ɫɩɟɰɢɮɢɤɚɰɢɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɩɪɢɫɭɬɫɬɜɭɟɬ ɡɧɚɤ *, ɬɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɩɨɥɟ ɜɜɨɞɚ ɩɪɨɩɭɫɤɚɟɬɫɹ, ɢ ɩɪɢɫɜɚɢɜɚɧɢɟ ɧɟ ɜɵɩɨɥɧɹɟɬɫɹ.
ɉɨɥɟ ɜɜɨɞɚ ɨɩɪɟɞɟɥɹɟɬɫɹ ɤɚɤ ɫɬɪɨɤɚ ɛɟɡ ɫɢɦɜɨɥɨɜ-ɪɚɡɞɟɥɢɬɟɥɟɣ, ɨɧɨ ɩɪɨ-
ɫɬɢɪɚɟɬɫɹ ɞɨ ɫɥɟɞɭɸɳɟɝɨ ɫɢɦɜɨɥɚ
-ɪɚɡɞɟɥɢɬɟɥɹ ɢɥɢ ɠɟ ɨɝɪɚɧɢɱɟɧɨ ɲɢɪɢɧɨɣ
ɩɨɥɹ, ɟɫɥɢ ɨɧɚ ɡɚɞɚɧɚ. ɉɨɫɤɨɥɶɤɭ ɫɢɦɜɨɥ ɧɨɜɨɣ ɫɬɪɨɤɢ ɬɚɤɠɟ ɨɬɧɨɫɢɬɫɹ ɤ ɫɢɦɜɨɥɚɦ-ɪɚɡɞɟɥɢɬɟɥɹɦ, ɬɨ scanf ɩɪɢ ɱɬɟɧɢɢ ɛɭɞɟɬ ɞɟɥɚɬɶ ɩɟɪɟɜɨɞ ɫ ɨɞɧɨɣ ɫɬɪɨɤɢ ɧɚ ɞɪɭɝɭɸ.
ɋɢɦɜɨɥɚɦɢ-ɪɚɡɞɟɥɢɬɟɥɹɦɢ ɹɜɥɹɸɬɫɹ ɫɢɦɜɨɥɵ ɩɪɨɛɟɥɚ, ɬɚɛɭɥɹɰɢɢ, ɧɨɜɨɣ
ɫɬɪɨɤɢ, ɜɨɡɜɪɚɬɚ ɤɚɪɟɬɤɢ, ɜɟɪɬɢɤɚɥɶɧɨɣ ɬɚɛɭɥɹɰɢɢ ɢ ɩɟɪɟɜɨɞɚ ɫɬɪɚɧɢɰɵ.
ɋɢɦɜɨɥ-ɫɩɟɰɢɮɢɤɚɬɨɪ ɭɤɚɡɵɜɚɟɬ, ɤɚɤɢɦ
ɨɛɪɚɡɨɦ ɫɥɟɞɭɟɬ ɢɧɬɟɪɩɪɟɬɢɪɨ-
ɜɚɬɶ ɨɱɟɪɟɞɧɨɟ ɩɨɥɟ ɜɜɨɞɚ. ɋɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɚɪɝɭɦɟɧɬ ɞɨɥɠɟɧ ɛɵɬɶ ɭɤɚɡɚɬɟɥɟɦ, ɤɚɤ ɬɨɝɨ ɬɪɟɛɭɟɬ ɦɟɯɚɧɢɡɦ ɩɟɪɟɞɚɱɢ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ, ɩɪɢɧɹɬɵɣ
ɜ ɋɢ. ɋɢɦɜɨɥɵ-ɫɩɟɰɢɮɢɤɚɬɨɪɵ ɩɪɢɜɟɞɟɧɵ ɜ ɬɚɛɥɢɰɟ 3.1.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.1
ɋɩɟɰɢɮɢɤɚɬɨɪɵ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɞɥɹ ɮɭɧɤɰɢɢ scanf
ɋɢɦɜɨɥ Ɂɧɚɱɟɧɢɟ
%ɫ ɑɬɟɧɢɟ ɨɞɢɧɨɱɧɨɝɨ ɫɢɦɜɨɥɚ
%d ɑɬɟɧɢɟ ɞɟɫɹɬɢɱɧɨɝɨ ɰɟɥɨɝɨ ɱɢɫɥɚ
%i
ɑɬɟɧɢɟ ɰɟɥɨɝɨ ɱɢɫɥɚ ɜ ɞɟɫɹɬɢɱɧɨɦ, ɜɨɫɶɦɟɪɢɱɧɨɦ ɢɥɢ
ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɦ ɮɨɪɦɚɬɟ
%e ɑɬɟɧɢɟ ɱɢɫɥɚ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
%f ɑɬɟɧɢɟ ɱɢɫɥɚ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
%g ɑɬɟɧɢɟ ɱɢɫɥɚ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
%ɨ ɑɬɟɧɢɟ ɜɨɫɶɦɟɪɢɱɧɨɝɨ ɱɢɫɥɚ
77
Ɉ ɤ ɨ ɧ ɱ ɚ ɧ ɢ ɟ ɬ ɚ ɛ ɥ ɢ ɰ ɵ 3.1
ɋɢɦɜɨɥ Ɂɧɚɱɟɧɢɟ
%s ɑɬɟɧɢɟ ɫɬɪɨɤɢ
%x ɑɬɟɧɢɟ ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɝɨ ɱɢɫɥɚ
%ɪ ɑɬɟɧɢɟ ɭɤɚɡɚɬɟɥɹ
%n
ɉɪɢɧɢɦɚɟɬ ɰɟɥɨɟ ɡɧɚɱɟɧɢɟ, ɪɚɜɧɨɟ ɤɨɥɢɱɟɫɬɜɭ ɫɱɢɬɚɧɧɵɯ
ɫɢɦɜɨɥɨɜ
%u ɑɬɟɧɢɟ ɞɟɫɹɬɢɱɧɨɝɨ ɰɟɥɨɝɨ ɱɢɫɥɚ ɛɟɡ ɡɧɚɤɚ
%[ ] ɑɬɟɧɢɟ ɧɚɛɨɪɚ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ
%% ɑɬɟɧɢɟ ɡɧɚɤɚ ɩɪɨɰɟɧɬɚ
ɉɟɪɟɞ ɫɢɦɜɨɥɚɦɢ-ɫɩɟɰɢɮɢɤɚɬɨɪɚɦɢ d, l, ɨ, u ɢ x ɦɨɠɟɬ ɫɬɨɹɬɶ ɛɭɤɜɚ h,
ɭɤɚɡɵɜɚɸɳɚɹ ɧɚ ɬɨ, ɱɬɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɚɪɝɭɦɟɧɬ ɞɨɥɠɟɧ ɢɦɟɬɶ ɬɢɩ short*
(ɚ ɧɟ int*), ɢɥɢ l (ɥɚɬɢɧɫɤɚɹ ell), ɭɤɚɡɵɜɚɸɳɚɹ ɧɚ ɬɢɩ long*. ɉɟɪɟɞ ɫɢɦɜɨɥɚɦɢ-ɫɩɟɰɢɮɢɤɚɬɨɪɚɦɢ ɟ, f ɢ g ɦɨɠɟɬ ɫɬɨɹɬɶ ɛɭɤɜɚ l, ɭɤɚɡɵɜɚɸɳɚɹ, ɱɬɨ
ɬɢɩ ɚɪɝɭɦɟɧɬɚ – double * (ɚ ɧɟ
float *).
Ɋɚɫɫɦɨɬɪɢɦ ɩɪɨɝɪɚɦɦɭ-«ɤɚɥɶɤɭɥɹɬɨɪ», ɜ ɤɨɬɨɪɨɣ ɨɪɝɚɧɢɡɭɟɦ ɜɜɨɞ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ scanf ɢ ɫɭɦɦɢɪɨɜɚɧɢɟ ɜɜɟɞɟɧɧɵɯ ɡɧɚɱɟɧɢɣ.
ɉɪɢɦɟɪ 3.2. Ɏɨɪɦɚɬɢɪɨɜɚɧɧɵɣ ɜɜɨɞ ɫ ɤɥɚɜɢɚɬɭɪɵ.
#include <stdio.h>
main() /* ɩɪɨɝɪɚɦɦɚ-ɤɚɥɶɤɭɥɹɬɨɪ */
{
double sum = 0.0, v = 0.0;
while (scanf ("%lf", &v) == 1)
printf("\t%.2f\n", sum += v);
return 0; }
Ɍɟɩɟɪɶ ɞɨɩɭɫɬɢɦ, ɱɬɨ ɧɚɦ ɧɭɠɧɨ ɩɪɨɱɢɬɚɬɶ ɫɬɪɨɤɢ ɜɜɨɞɚ, ɫɨɞɟɪɠɚɳɢɟ
ɞɚɧɧɵɟ ɜɢɞɚ 25 ɞɟɤ 2017, ɬ. ɟ. ɞɚɬɭ. Ɉɛɪɚɳɟɧɢɟ ɤ scanf ɞɥɹ ɜɜɨɞɚ ɞɚɬɵ
ɜɵɝɥɹɞɢɬ ɫɥɟɞɭɸɳɢɦ
ɨɛɪɚɡɨɦ:
int day, year; /* ɞɟɧɶ, ɝɨɞ */
char monthname[20]; /* ɧɚɡɜɚɧɢɟ ɦɟɫɹɰɚ */
scanf("%d %s %d", &day, monthname, &year);
Ɂɧɚɤ &ɩɟɪɟɞ monthname ɧɟ ɧɭɠɟɧ, ɬɚɤ ɤɚɤ ɢɦɹ ɦɚɫɫɢɜɚ ɭɠɟ ɹɜɥɹɟɬɫɹ
ɭɤɚɡɚɬɟɥɟɦ.
ȼ ɫɬɪɨɤɟ ɮɨɪɦɚɬɚ ɦɨɝɭɬ ɬɚɤɠɟ ɩɪɢɫɭɬɫɬɜɨɜɚɬɶ ɫɢɦɜɨɥɵ, ɧɟ ɭɱɚɫɬɜɭɸɳɢɟ
ɧɢ ɜ ɨɞɧɨɣ ɢɡ ɫɩɟɰɢɮɢɤɚɰɢɣ; ɷɬɨ ɡɧɚɱɢɬ, ɱɬɨ ɷɬɢ ɫɢɦɜɨɥɵ ɞɨɥɠɧɵ ɩɨɹɜɢɬɶɫɹ ɧɚ
ɜɜɨɞɟ ɜ ɬɚɤɨɦ ɜɢɞɟ, ɤɚɤ ɨɧɢ ɡɚɩɢɫɚɧɵ.
ɉɪɨɱɢɬɚɬɶ ɞɚɬɵ ɦɨɠɧɨ
ɢ ɜ ɮɨɪɦɚɬɟ mm/dd/yy:
int day, month, year; /* ɞɟɧɶ, ɦɟɫɹɰ, ɝɨɞ */
scanf("%d/%d/%d", &day, &month, &year);
78
Ɉɛɪɚɳɟɧɢɹ ɤ ɮɭɧɤɰɢɢ scanf ɦɨɝɭɬ ɩɟɪɟɦɟɠɚɬɶɫɹ ɫ ɜɵɡɨɜɚɦɢ ɞɪɭɝɢɯ
ɮɭɧɤɰɢɣ ɜɜɨɞɚ.
Ʌɸɛɚɹ ɮɭɧɤɰɢɹ ɜɜɨɞɚ, ɜɵɡɜɚɧɧɚɹ ɩɨɫɥɟ scanf, ɩɪɨɞɨɥɠɢɬ ɱɬɟɧɢɟ ɫ ɩɟɪɜɨɝɨ ɟɳɟ ɧɟɩɪɨɱɢɬɚɧɧɨɝɨ ɫɢɦɜɨɥɚ.
ȼɧɢɦɚɧɢɟ!!! Ⱥɪɝɭɦɟɧɬɵ ɮɭɧɤɰɢɢ scanf ɞɨɥɠɧɵ ɛɵɬɶ ɭɤɚɡɚɬɟɥɹɦɢ! Ɉɞɧɚ ɢɡ ɫɚɦɵɯ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ ɨɲɢɛɨɤ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɮɭɧɤɰɢɢ scanf
ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɜɦɟɫɬɨ ɬɨɝɨ, ɱɬɨɛɵ ɧɚɩɢɫɚɬɶ scanf("%d", &n), ɢɧɨɝɞɚ
ɩɢɲɭɬ scanf("%d", n), ɚ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɜɢɞɢɬ ɜ ɷɬɨɦ ɨɲɢɛɤɢ!
Ɏɭɧɤɰɢɹ scanf() ɩɨɞɞɟɪɠɢɜɚɟɬ ɫɩɟɰɢɮɢɤɚɬɨɪ ɮɨɪɦɚɬɚ ɨɛɳɟɝɨ ɧɚɡɧɚɱɟɧɢɹ, ɧɚɡɵɜɚɟɦɵɣ ɧɚɛɨɪɨɦ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ, ɤɨɬɨɪɵɣ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɦɧɨɠɟɫɬɜɨ ɫɢɦɜɨɥɨɜ. Ʉɨɝɞɚ scanf() ɨɛɪɚɛɚɬɵɜɚɟɬ ɷɬɨ ɦɧɨɠɟɫɬɜɨ, ɬɨ ɜ
ɩɪɨɝɪɚɦɦɭ ɜɜɨɞɹɬɫɹ ɬɨɥɶɤɨ ɬɟ ɫɢɦɜɨɥɵ, ɤɨɬɨɪɵɟ ɜɯɨɞɹɬ ɜ ɡɚɞɚɧɧɵɣ ɧɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ. Ɍɚɤɨɣ ɩɪɢɟɦ ɧɚɡɵɜɚɸɬ ɮɢɥɶɬɪɚɰɢɟɣ
ɜɜɨɞɚ.
ɑɢɬɚɟɦɵɟ ɫɢɦɜɨɥɵ ɛɭɞɭɬ ɩɨɦɟɳɚɬɶɫɹ ɜ ɦɚɫɫɢɜ ɫɢɦɜɨɥɨɜ, ɤɨɬɨɪɵɣ ɭɤɚɡɚɧ
ɚɪɝɭɦɟɧɬɨɦ, ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ ɧɚɛɨɪɭ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ: ɜɫɟ ɬɟ ɫɢɦɜɨɥɵ,
ɤɨɬɨɪɵɟ ɩɪɟɞɫɬɨɢɬ ɫɤɚɧɢɪɨɜɚɬɶ, ɩɨɦɟɳɚɸɬ ɜ ɤɜɚɞɪɚɬɧɵɟ ɫɤɨɛɤɢ. ɇɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɩɟɪɟɞ ɨɬɤɪɵɜɚɸɳɟɣ ɤɜɚɞɪɚɬɧɨɣ ɫɤɨɛɤɨɣ ɞɨɥɠɟɧ ɧɚɯɨɞɢɬɶɫɹ ɡɧɚɤ %.
ɇɚɩɪɢɦɟɪ, ɫɥɟɞɭɸɳɢɣ ɧɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ ɞɚɟɬ ɭɤɚɡɚɧɢɟ
scanf() ɫɤɚɧɢɪɨɜɚɬɶ ɬɨɥɶɤɨ ɫɢɦɜɨɥɵ X, Y ɢ Z: %[XYZ].
Ɍɚɤɢɦ ɨɛɪɚɡɨɦ
, ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɧɚɛɨɪɚ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ ɮɭɧɤɰɢɹ scanf() ɩɪɨɞɨɥɠɚɟɬ ɱɢɬɚɬɶ ɫɢɦɜɨɥɵ, ɩɨɦɟɳɚɹ ɢɯ ɜ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ
ɦɚɫɫɢɜ ɫɢɦɜɨɥɨɜ, ɩɨɤɚ ɧɟ ɜɫɬɪɟɬɢɬɫɹ ɫɢɦɜɨɥ, ɧɟ ɜɯɨɞɹɳɢɣ ɜ ɷɬɨɬ ɧɚɛɨɪ.
ɉɪɢɦɟɪ 3.3. Ɏɨɪɦɚɬɢɪɨɜɚɧɧɵɣ ɜɜɨɞ ɫ ɤɥɚɜɢɚɬɭɪɵ ɫ ɮɢɥɶɬɪɚɰɢɟɣ.
#include <stdio.h>
int main(void) {
int i; char str[80], str2[80];
scanf("%d%[abcdefg]%s", &i, str, str2);
printf("%d %s %s", i, str, str2);
return 0;
}
ȼɜɟɞɢɬɟ ɫɬɪɨɤɭ "123abcdtye", ɚ ɡɚɬɟɦ ɧɚɠɦɢɬɟ ɤɥɚɜɢɲɭ <ENTER>. ɉɨ-
ɫɥɟ ɷɬɨɝɨ ɩɪɨɝɪɚɦɦɚ ɜɵɜɟɞɟɬ 123 abed tye. Ɍɚɤ ɤɚɤ
't'ɧɟ ɜɯɨɞɢɬ ɜ ɧɚɛɨɪ
ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ, ɬɨ scanf() ɩɪɟɤɪɚɬɢɥɚ ɱɬɟɧɢɟ ɫɢɦɜɨɥɨɜ ɜ ɩɟɪɟɦɟɧɧɭɸ str ɫɪɚɡɭ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɜɫɬɪɟɬɢɥɫɹ ɫɢɦɜɨɥ 't', ɚ ɨɫɬɚɜɲɢɟɫɹ ɫɢɦɜɨɥɵ
ɛɵɥɢ ɩɨɦɟɳɟɧɵ ɜ ɩɟɪɟɦɟɧɧɭɸ str2.
ɂɫɩɨɥɶɡɭɹ ɪɚɫɫɦɨɬɪɟɧɧɵɣ ɦɟɯɚɧɢɡɦ, ɦɨɠɧɨ ɭɤɚɡɚɬɶ ɧɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ
ɫɢɦɜɨɥɨɜ, ɪɚɛɨɬɚɸɳɢɣ ɫ ɬɨɱɧɨɫɬɶɸ ɞɨ ɧɚɨɛɨɪɨɬ, – ɬɨɝɞɚ ɩɟɪɜɵɦ ɫɢɦɜɨɥɨɦ ɜ
ɬɚɤɨɦ ɧɚɛɨɪɟ ɞɨɥɠɟɧ
ɛɵɬɶ ‘Ⱥ’, ɤɨɬɨɪɵɣ ɞɚɟɬ ɭɤɚɡɚɧɢɟ scanf() ɩɪɢɧɢɦɚɬɶ
ɥɸɛɨɣ ɫɢɦɜɨɥ, ɤɨɬɨɪɵɣ ɧɟ ɜɯɨɞɢɬ ɜ ɧɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ.
ȼ ɛɨɥɶɲɢɧɫɬɜɟ ɪɟɚɥɢɡɚɰɢɣ ɋɢ ɞɥɹ ɭɤɚɡɚɧɢɹ ɞɢɚɩɚɡɨɧɚ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɡɧɚɤ ɞɟɮɢɫɚ. ɇɚɩɪɢɦɟɪ, ɧɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ %[A- Z]
ɞɚɟɬ ɮɭɧɤɰɢɢ scanf() ɭɤɚɡɚɧɢɟ ɩɪɢɧɢɦɚɬɶ ɫɢɦɜɨɥɵ ɨɬ ‘Ⱥ’ ɞɨ ’Z’.
79
ɇɚɛɨɪ ɫɤɚɧɢɪɭɟɦɵɯ ɫɢɦɜɨɥɨɜ ɱɭɜɫɬɜɢɬɟɥɟɧ ɤ ɪɟɝɢɫɬɪɭ ɛɭɤɜ. ȿɫɥɢ ɧɭɠɧɨ
ɫɤɚɧɢɪɨɜɚɬɶ ɛɭɤɜɵ ɢ ɧɚ ɜɟɪɯɧɟɦ, ɢ ɧɚ ɧɢɠɧɟɦ ɪɟɝɢɫɬɪɟ, ɬɨ ɢɯ ɫɥɟɞɭɟɬ ɭɤɚɡɚɬɶ
ɨɬɞɟɥɶɧɨ ɞɥɹ ɤɚɠɞɨɝɨ ɪɟɝɢɫɬɪɚ.
Ɍɟɩɟɪɶ ɪɚɫɫɦɨɬɪɢɦ ɮɭɧɤɰɢɢ ɋɢ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɜɵɜɨɞɚ
ɧɚ ɷɤɪɚɧ.
Ɏɭɧɤɰɢɹ int putchar(int c) ɨɬɩɪɚɜɥɹɟɬ ɫɢɦɜɨɥ c ɜ ɫɬɚɧɞɚɪɬɧɵɣ
ɜɵɜɨɞ (ɩɨ ɭɦɨɥɱɚɧɢɸ ɷɬɨ ɷɤɪɚɧ ɦɨɲɬɨɪɚ).
ȼ ɤɚɱɟɫɬɜɟ
ɩɪɢɦɟɪɚ ɪɚɫɫɦɨɬɪɢɦ ɩɪɨɝɪɚɦɦɭ, ɤɨɬɨɪɚɹ ɨɫɭɳɟɫɬɜɥɹɟɬ ɜɜɨɞ
ɫɢɦɜɨɥɨɜ ɢ ɩɟɪɟɜɨɞɢɬ ɜɜɟɞɟɧɧɵɟ ɫɢɦɜɨɥɵ ɜ ɧɢɠɧɢɣ ɪɟɝɢɫɬɪ:
ɉɪɢɦɟɪ 3.4. ȼɵɜɨɞ ɫɢɦɜɨɥɚ ɧɚ ɷɤɪɚɧ.
#include <stdio.h>
#include <ctype.h>
int main() {
int ɫ;
while ((ɫ = getchar()) != EOF)
/* tolower: ɩɟɪɟɜɨɞɢɬ ɜɜɨɞ ɧɚ ɧɢɠɧɢɣ ɪɟɝɢɫɬɪ */ /*
tolower ɨɩɪɟɞɟɥɟɧɚ ɜ <ctype.h>*/ putchar(tolower(c));
return 0; }
ȼ ɋɢ ɮɨɪɦɚɬɢɪɨɜɚɧɧɵɣ ɜɵɜɨɞ ɨɫɭɳɟɫɬɜɥɹɟɬ ɮɭɧɤɰɢɹ printf, ɤɨɬɨɪɚɹ
ɩɪɟɨɛɪɚɡɭɟɬ, ɮɨɪɦɚɬɢɪɭɟɬ ɢ ɩɟɱɚɬɚɟɬ ɩɟɪɟɞɚɧɧɵɟ ɚɪɝɭɦɟɧɬɵ ɜ ɫɬɚɧɞɚɪɬɧɨɦ ɜɵɜɨɞɟ
ɩɨɞ ɭɩɪɚɜɥɟɧɢɟɦ ɮɨɪɦɚɬɚ. ȼɨɡɜɪɚɳɚɟɬ ɮɭɧɤɰɢɹ printf ɤɨɥɢɱɟɫɬɜɨ
ɧɚɩɟɱɚɬɚɧɧɵɯ ɫɢɦɜɨɥɨɜ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ printf ɫɥɟɞɭɸɳɢɣ:
int printf(char *format, argr arg2, ...)
ɋɬɪɨɤɚ ɮɨɪɦɚɬɚ format ɫɨɞɟɪɠɢɬ ɞɜɚ ɜɢɞɚ ɨɛɴɟɤɬɨɜ: ɨɛɵɱɧɵɟ ɫɢɦɜɨɥɵ,
ɤɨɬɨɪɵɟ ɧɚɩɪɹɦɭɸ ɩɟɪɟɞɚɸɬɫɹ ɜ ɜɵɯɨɞɧɨɣ ɩɨɬɨɤ, ɢ ɫɩɟɰɢɮɢɤɚɰɢɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ, ɤɚɠɞɚɹ ɢɡ ɤɨɬɨɪɵɯ ɜɵɡɵɜɚɟɬ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɢ ɩɟɱɚɬɶ ɨɱɟɪɟɞɧɨɝɨ ɚɪɝɭɦɟɧɬɚ printf.
Ʌɸɛɚɹ ɫɩɟɰɢɮɢɤɚɰɢɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɧɚɱɢɧɚɟɬɫɹ ɫɢɦɜɨɥɨɦ ‘%’ ɢ ɡɚɤɚɧɱɢ-
ɫɢɦɜɨɥɨɦ-ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ. ɋɢɦɜɨɥɵ-ɫɩɟɰɢɮɢɤɚɬɨɪɵ ɩɟɪɟɱɢɫɥɟɧɵ ɜ
ɜɚɟɬɫɹ
ɬɚɛɥɢɰɟ 3.2.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.2
ɋɩɟɰɢɮɢɤɚɬɨɪɵ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɞɥɹ ɮɭɧɤɰɢɢ printf
ɋɢɦɜɨɥ
Ɂɧɚɱɟɧɢɟ
%ɫ ɋɢɦɜɨɥ
%d Ⱦɟɫɹɬɢɱɧɨɟ ɰɟɥɨɟ ɫɨ ɡɧɚɤɨɦ
%i Ⱦɟɫɹɬɢɱɧɨɟ ɰɟɥɨɟ ɫɨ ɡɧɚɤɨɦ
%e ɗɤɫɩɨɧɟɧɰɢɚɥɶɧɨɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ ('ɟ' ɜ ɧɢɠɧɟɦ ɪɟɝɢɫɬɪɟ)
%E ɗɤɫɩɨɧɟɧɰɢɚɥɶɧɨɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ ('ȿ' ɜ ɜɟɪɯɧɟɦ ɪɟɝɢɫɬɪɟ)
%f Ⱦɟɫɹɬɢɱɧɨɟ ɫ ɩɥɚɜɚɸɳɟɣ ɬɨɱɤɨɣ
%g
ȼ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɨɝɨ, ɤɚɤɨɣ ɜɵɜɨɞ ɛɭɞɟɬ ɤɨɪɨɱɟ, ɢɫɩɨɥɶɡɭɟɬɫɹ %ɟ ɢɥɢ %f
80
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]