Добавил:

ivanov666 Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Башкирский Государственный Аграрный Университет

Предмет:

[НЕСОРТИРОВАННОЕ]

Файл:

Системное программирование. Учебное пособие-1

.pdf

Скачиваний:

Добавлен:

08.09.2026

Размер:

2 Мб

Скачать

☆

<<< < Предыдущая 1 2 3 45 / 205 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 > Следующая >>>

Ɉɩɟɪɚɬɨɪ ɩɨɜɬɨɪɹɟɬɫɹ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɜɵɪɚɠɟɧɢɟ ɧɟ ɫɬɚɧɟɬ ɥɨɠɧɵɦ ɢɥɢ ɧɭɥɟɦ. ȼɵɪɚɠɟɧɢɟ ɦɨɠɟɬ ɛɵɬɶ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɬɢɩɚ.

Ɋɚɫɫɦɨɬɪɢɦ ɩɪɢɦɟɪɵ.

ɉɪɢɦɟɪ 2.23. ɉɪɨɫɬɨɣ ɰɢɤɥ while.

int df = 2, f = 5;

while (f<100) { f = f+df; printf(f);

}

ɉɪɢɜɟɞɟɧɧɵɣ ɮɪɚɝɦɟɧɬ ɩɪɨɝɪɚɦɦɵ ɜɵɜɨɞɢɬ ɱɢɫɥɚ ɨɬ 5 ɞɨ 100.

ɉɪɢɦɟɪ 2.24. ɐɢɤɥ while ɫ ɭɫɥɨɜɢɟɦ, ɨɩɪɟɞɟɥɹɟɦɵɦ ɜɜɨɞɨɦ ɩɨɥɶɡɨɜɚɬɟɥɹ.

#include <stdio.h>

#include <locale.h>

int guess = 1;

char response;

int main () {

setlocale(LC_ALL, "RUS");

printf("Ɂɚɝɚɞɚɣɬɟ ɱɢɫɥɨ ɨɬ 1 ɞɨ 100 \n"); printf("A ɹ

ɩɨɩɪɨɛɭɸ ɭɝɚɞɚɬɶ ɟɝɨ \n");

printf("Ɉɬɜɟɱɚɣɬɟ Y,

ɟɫɥɢ

ɞɨɝɚɞɤɚ ɜɟɪɧɚ, \n"); printf("ɢ N, ɟɫɥɢ ɹ ɨɲɢɛɚɸɫɶ \n"); printf("ɂɬɚɤ, ȼɚɲɟ ɱɢɫɥɨ . . .\n"); scanf("%d",guess); while ((response=getch())!='Y') if (response!='\n') { printf("Hy, ɬɨɝɞɚ ɨɧɨ ɪɚɜɧɨ . . . \n"); printf("%d \n", ++guess); } printf ("ɑɢɫɥɨ ɭɝɚɞɚɧɨ !!! \n"); return 0; }

ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɩɪɢɦɟɪɟ ɰɢɤɥ ɩɪɨɞɨɥɠɚɟɬɫɹ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ȼɵ ɧɟ ɨɬɜɟ-

ɬɢɬɟ Y (Yes). Ⱥɥɝɨɪɢɬɦ «ɭɝɚɞɵɜɚɧɢɹ» ɨɱɟɧɶ ɩɪɨɫɬɨɣ. ɋɧɚɱɚɥɚ ɩɪɨɝɪɚɦɦɚ ɩɪɟɞɥɨɠɢɬ ɜɚɦ ɱɢɫɥɨ 1, ɩɨɬɨɦ 2, 3, ɢ ɬ. ɞ. Ʉɨɝɞɚ ɱɢɫɥɨ, ɩɨɞɫɱɢɬɚɧɧɨɟ ɩɪɨɝɪɚɦɦɨɣ

ɛɭɞɟɬ ɪɚɜɧɨ ɬɨɦɭ, ɤɨɬɨɪɨɟ ȼɵ ɡɚɝɚɞɚɥɢ, ȼɵ, ɤɨɧɟɱɧɨ, ɨɬɜɟɬɢɬɟ Y.

Ɉɛɚ ɰɢɤɥɚ, for ɢ while, ɮɚɤɬɢɱɟɫɤɢ ɹɜɥɹɸɬɫɹ ɰɢɤɥɚɦɢ ɫ ɩɪɟɞɭɫɥɨɜɢɟɦ.

ɉɪɨɜɟɪɤɚ ɢɫɬɢɧɧɨɫɬɢ ɭɫɥɨɜɢɹ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɩɟɪɟɞ ɧɚɱɚɥɨɦ ɤɚɠɞɨɣ ɢɬɟɪɚɰɢɢ ɰɢɤɥɚ.

Ɉɩɟɪɚɬɨɪ do while ɩɨɡɜɨɥɹɟɬ ɢɡɦɟɧɢɬɶ ɩɨɪɹɞɨɤ ɩɪɨɜɟɪɤɢ, ɨɧ ɩɪɨɜɟɪɹ-

ɟɬ ɭɫɥɨɜɢɟ ɩɨɫɥɟ ɨɤɨɧɱɚɧɢɹ ɤɚɠɞɨɣ ɢɬɟɪɚɰɢɢ ɰɢɤɥɚ, ɬɨ ɟɫɬɶ ɹɜɥɹɟɬɫɹ ɰɢɤɥɨɦ ɫ ɩɨɫɬɭɫɥɨɜɢɟɦ. Ɏɨɪɦɚɬ

ɨɩɟɪɚɬɨɪɚ:

do ɨɩɟɪɚɬɨɪ while (ɜɵɪɚɠɟɧɢɟ); Ɉɩɟɪɚɬɨɪ ɩɨɜɬɨɪɹɟɬɫɹ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɜɵɪɚɠɟɧɢɟ ɧɟ ɫɬɚɧɟɬ ɥɨɠɧɵɦ

ɢɥɢ ɧɭɥɟɦ.

ɉɪɢɦɟɪ 2.25. ɐɢɤɥ do while.

#include <stdio.h> #include <math.h> void main() {

int i =10; double z, y = 5.6, m; do { z = 22 - (y/3.0)*i; m = 33.3*cos(z); printf("i = %d z = %f \n", i, z); } while (--i); }

ɉɨɞɤɥɸɱɟɧɢɟ ɡɚɝɨɥɨɜɨɱɧɨɝɨ ɮɚɣɥɚ math.h ɜ ɧɚɱɚɥɟ ɩɪɨɝɪɚɦɦɵ ɧɟɨɛɯɨ-

ɞɢɦɨ ɞɥɹ ɜɵɡɨɜɚ ɫɬɚɧɞɚɪɬɧɨɣ ɮɭɧɤɰɢɢ ɤɨɫɢɧɭɫɚ.

Ɉɩɪɟɞɟɥɢɬɟ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ, ɱɬɨ ɜɵɜɟɞɟɬ ɷɬɚ ɩɪɨɝɪɚɦɦɚ ɧɚ ɷɤɪɚɧ. ȼ ɩɪɨɝɪɚɦɦɟ ɰɢɤɥɵ ɦɨɝɭɬ ɜɤɥɚɞɵɜɚɬɶɫɹ ɞɪɭɝ ɜ ɞɪɭɝɚ. ȼɥɨɠɟɧɧɵɦ ɧɚɡɵɜɚɟɬɫɹ ɰɢɤɥ, ɧɚɯɨɞɹɳɢɣɫɹ ɜɧɭɬɪɢ ɞɪɭɝɨɝɨ ɰɢɤɥɚ. Ʉɨɥɢɱɟ-

ɫɬɜɨ ɜɥɨɠɟɧɢɣ ɧɟ ɨɝɪɚɧɢɱɟɧɨ. Ɉɞɧɚɤɨ ɧɚ ɩɪɚɤɬɢɤɟ ɤɨɥɢɱɟɫɬɜɨ ɜɥɨɠɟɧɢɣ ɧɚɯɨɞɢɬɫɹ ɜ ɩɪɟɞɟɥɚɯ 1-3.

ɉɪɢɦɟɪ 2.26. ȼɥɨɠɟɧɧɵɟ ɰɢɤɥɵ.

int j,k,z; for (j=0;j<10;j++){ k = j-1; while (k<5) { z = 2*k;k--; printf(“Z=%d”,z); }}

ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɮɪɚɝɦɟɧɬɟ ɩɪɨɝɪɚɦɦɵ ɜɨ ɜɧɭɬɪɟɧɧɟɦ ɰɢɤɥɟ ɧɚ ɷɤɪɚɧ ɜɵɜɨ-

ɞɢɬɫɹ ɩɟɪɟɦɟɧɧɚɹ z ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɩɟɪɟɦɟɧɧɚɹ k ɦɟɧɶɲɟ 5. ȼɟɥɢɱɢɧɚ k ɩɪɢ ɷɬɨɦ ɨɩɪɟɞɟɥɹɟɬɫɹ ɩɟɪɟɦɟɧɧɨɣ j ɜɨ ɜɧɟɲɧɟɦ ɰɢɤɥɟ. Ɉɩɪɟɞɟɥɢɬɟ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ, ɱɬɨ ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɧɚ ɷɤɪɚɧ.

Ɉɩɟɪɚɬɨɪɵ ɰɢɤɥɨɜ ɢ ɭɫɥɨɜɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɪɚɫɫɦɨɬɪɟɧɧɵɟ

ɧɚɦɢ ɜɵɲɟ, ɹɜɥɹɸɬɫɹ ɜɚɠɧɟɣɲɢɦɢ ɫɪɟɞɫɬɜɚɦɢ ɭɩɪɚɜɥɟɧɢɹ ɜɵɩɨɥɧɟɧɢɟɦ ɩɪɨɝɪɚɦɦɵ ɧɚ ɋɢ. Ɉɞɧɚɤɨ ɟɫɬɶ ɟɳɟ ɞɜɚ ɧɟ ɦɟɧɟɟ ɜɚɠɧɵɯ ɨɩɟɪɚɬɨɪɚ – break ɢ continue, ɤɨɬɨɪɵɟ ɩɨɡɜɨɥɹɸɬ ɪɚɫɲɢɪɢɬɶ ɜɨɡɦɨɠɧɨɫɬɢ ɞɪɭɝɢɯ ɨɩɟɪɚɬɨɪɨɜ ɭɩɪɚɜɥɟɧɢɹ.

ɋ ɨɩɟɪɚɬɨɪɨɦ break ɦɵ ɭɠɟ ɩɨɡɧɚɤɨɦɢɥɢɫɶ ɩɪɢ ɢɡɭɱɟɧɢɢ ɨɩɟɪɚɬɨɪɚ

switch. Ɋɚɫɫɦɨɬɪɢɦ ɟɝɨ ɩɨɞɪɨɛɧɟɟ.

Ɉɩɟɪɚɬɨɪ break ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɡɚɜɟɪɲɟɧɢɹ ɰɢɤɥɨɜ ɢ ɛɥɨɤɨɜ ɜ

ɨɩɟɪɚ-

ɬɨɪɟ switch. Ʉɨɝɞɚ ɜ ɯɨɞɟ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɜɫɬɪɟɱɚɟɬɫɹ ɷɬɨ ɜɵɪɚɠɟɧɢɟ, ɟɝɨ ɜɵɩɨɥɧɟɧɢɟ ɩɪɢɜɨɞɢɬ ɤ ɜɵɯɨɞɭ ɢɡ ɤɨɧɫɬɪɭɤɰɢɢ switch, for, while ɢɥɢ do while, ɜ ɤɨɬɨɪɵɯ ɨɧ ɫɨɞɟɪɠɢɬɫɹ, ɢ ɩɟɪɟɯɨɞɭ ɤ ɫɥɟɞɭɸɳɟɦɭ ɨɩɟɪɚɬɨɪɭ ɩɪɨɝɪɚɦɦɵ. ȿɫɥɢ ɠɟ ɜɵɪɚɠɟɧɢɟ break ɧɚɯɨɞɢɬɫɹ ɜɧɭɬɪɢ ɧɟɤɨɬɨɪɨɣ ɫɨɜɨɤɭɩɧɨɫɬɢ ɜɥɨɠɟɧɧɵɯ ɫɬɪɭɤɬɭɪ, ɟɝɨ ɞɟɣɫɬɜɢɟ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ ɬɨɥɶɤɨ ɧɚ ɫɚɦɭɸ ɜɧɭɬɪɟɧɧɸɸ

ɫɬɪɭɤɬɭɪɭ, ɜ ɤɨɬɨɪɨɣ ɨɧ ɫɨɞɟɪɠɢɬɫɹ.

ȼ ɩɪɢɜɟɞɟɧɧɨɣ ɧɢɠɟ ɩɪɨɝɪɚɦɦɟ ɩɨɤɚɡɚɧɨ, ɤɚɤ ɪɚɛɨɬɚɟɬ ɜɵɪɚɠɟɧɢɟ break,

ɪɚɫɩɨɥɨɠɟɧɧɨɟ ɜɧɭɬɪɢ ɰɢɤɥɚ while.

ɉɪɢɦɟɪ 2.27. Ɉɩɟɪɚɬɨɪ break ɜ ɰɢɤɥɟ while.

#include <stdio.h> #include <locale.h> void main() { setlocale(LC_ALL, "RUS"); int num, sum, count; printf("Beegume 10 ɩɨɥɨɠɢɬɟɥɶɧɵɯ ɱɢɫɟɥ \n"); while (++count <=10) {

scanf("%d",num);

if (num <0) {

printf("Ɉɲɢɛɤɚ: \n"); printf("Bɜegeɧɨ ɨɬɪɢɰɚɬɟɥɶɧɨɟ ɱɢɫɥɨ \n"); printf("Ha ɲɚɝɟ %d", count);

break;

}

sum = sum + number;

}

printf("ɋɭɦɦɚ %d ɱɢɫɟɥ ɪɚɜɧɚ %d", (count-1), sum); }

ȼɵɪɚɠɟɧɢɟ continue ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜɨ ɜɫɟɯ ɬɪɟɯ ɜɢɞɚɯ ɰɢɤɥɨɜ. Ɉɧɨ ɡɚɜɟɪɲɚɟɬ ɬɟɤɭɳɭɸ ɢɬɟɪɚɰɢɸ ɰɢɤɥɚ ɢ ɧɚɱɢɧɚɟɬ ɧɨɜɭɸ. ɉɟɪɟɩɢɲɟɦ ɩɪɢɜɟɞɟɧɧɭɸ ɜɵɲɟ ɩɪɨɝɪɚɦɦɭ ɭɤɚɡɚɧɧɵɦ ɨɛɪɚɡɨɦ.

ɉɪɢɦɟɪ 2.28. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɨɩɟɪɚɬɨɪɚ continue.

#include <stdio.h> #include <locale.h> void main() { setlocale(LC_ALL, "RUS"); int num, sum, count; printf("ȼɜɟɞɢɬɟ 10 ɩɨɥɨɠɢɬɟɥɶɧɵɯ ɱɢɫɟɥ \n"); while (++count <=10) {

scanf("%d",num);

if (num <0) {

printf("Ɉɲɢɛɤɚ: \n"); printf("Bɜegeɧɨ ɨɬɪɢɰɚɬɟɥɶɧɨɟ ɱɢɫɥɨ \n"); printf("Ha ɲɚɝɟ %d", count); printf("ɩɨɜɬɨɪɢɬɟ ɜɜɨɞ \n"); count--;

continue;

break; }

sum = sum + number;

} printf("ɋɭɦɦɚ %d ɱɢɫɟɥ ɪɚɜɧɚ %d", (count-1), sum); }

ɉɪɨɝɪɚɦɦɚ ɫɬɚɥɚ ɛɨɥɟɟ ɝɢɛɤɨɣ – ɜɦɟɫɬɨ ɬɨɝɨ, ɱɬɨɛɵ ɡɚɜɟɪɲɚɬɶ ɪɚɛɨɬɭ ɩɪɢ ɜɜɨɞɟ ɧɟɜɟɪɧɨɝɨ ɱɢɫɥɚ, ɨɧɚ ɩɪɟɞɥɨɠɢɬ ɩɨɥɶɡɨɜɚɬɟɥɸ ɩɨɜɬɨɪɢɬɶ ɜɜɨɞ ɢ ɜɟɪɧɟɬ ɧɚ ɧɚɱɚɥɨ ɰɢɤɥɚ.

2.1.3. Ɏɭɧɤɰɢɢ

Ɏɭɧɤɰɢɹ – ɷɬɨ ɩɨɥɧɨɫɬɶɸ ɡɚɜɟɪɲɟɧɧɵɣ ɢɦɟɧɨɜɚɧɧɵɣ ɛɥɨɤ ɩɪɨɝɪɚɦɦɵ ɋɢ, ɤɨɬɨɪɵɣ ɜɵɩɨɥɧɹɟɬ ɡɚɞɚɧɧɵɣ ɧɚɛɨɪ ɞɟɣɫɬɜɢɣ.

ɋɢɧɬɚɤɫɢɫ ɨɛɴɹɜɥɟɧɢɹ ɮɭɧɤɰɢɢ ɜ ɋɢ ɫɥɟɞɭɸɳɢɣ:

Ɍɢɩ ɂɦɹɎɭɧɤɰɢɢ([ɜɯɨɞɧɵɟ ɩɚɪɚɦɟɬɪɵ])

{

ɬɟɥɨ ɮɭɧɤɰɢɢ

}

Ɍɢɩ ɨɩɪɟɞɟɥɹɟɬ ɬɢɩ ɪɟɡɭɥɶɬɚɬɚ, ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɮɭɧɤɰɢɟɣ. Ɏɭɧɤɰɢɹ ɦɨ- ɠɟɬ ɜɨɡɜɪɚɳɚɬɶ ɪɟɡɭɥɶɬɚɬ ɥɸɛɨɝɨ ɬɢɩɚ ɞɚɧɧɵɯ. ȼɯɨɞɧɵɟ ɩɚɪɚɦɟɬɪɵ – ɷɬɨ ɫɩɢɫɨɤ ɜɧɭɬɪɟɧɧɢɯ ɩɟɪɟɦɟɧɧɵɯ ɮɭɧɤɰɢɢ, ɱɟɪɟɡ

ɤɨɬɨɪɵɟ ɜ ɮɭɧɤɰɢɸ ɩɟɪɟɞɚɸɬɫɹ ɡɧɚɱɟɧɢɹ ɢɡ ɨɫɧɨɜɧɨɣ ɩɪɨɝɪɚɦɦɵ. Ɏɭɧɤɰɢɹ ɦɨɠɟɬ ɛɵɬɶ ɢ ɛɟɡ ɩɚɪɚɦɟɬɪɨɜ, ɬɨɝɞɚ ɢɯ ɫɩɢɫɨɤ ɛɭɞɟɬ ɩɭɫɬɵɦ. Ɍɚɤɨɣ ɩɭɫɬɨɣ ɫɩɢɫɨɤ ɦɨɠɧɨ ɭɤɚɡɚɬɶ ɢ ɜ ɹɜɧɨɦ ɜɢɞɟ, ɩɨɦɟɫɬɢɜ ɞɥɹ ɷɬɨɝɨ ɜɧɭɬɪɢ ɫɤɨɛɨɤ ɤɥɸɱɟɜɨɟ ɫɥɨɜɨ void.

ȼɫɟ ɜɯɨɞɧɵɟ ɩɚɪɚɦɟɬɪɵ ɮɭɧɤɰɢɣ ɞɨɥɠɧɵ ɨɛɴɹɜɥɹɬɶɫɹ ɨɬɞɟɥɶɧɨ, ɩɪɢɱɟɦ

ɞɥɹ ɤɚɠɞɨɝɨ ɢɡ ɧɢɯ ɧɚɞɨ ɭɤɚɡɵɜɚɬɶ

ɢ ɬɢɩ, ɢ ɢɦɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɩɢɫɨɤ ɨɛɴɹɜɥɟɧɢɣ ɩɚɪɚɦɟɬɪɨɜ ɞɨɥɠɟɧ ɜɵɝɥɹɞɟɬɶ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ: ɬɢɩ ɂɉ1, ɬɢɩ ɂɉ2, ..., ɬɢɩ ɂɉʋ, ɝɞɟ ɂɉ – ɢɦɹ ɩɟɪɟɦɟɧɧɨɣ.

ɉɪɢɦɟɪ 2.29. Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɵɯ ɜ ɡɚɝɨɥɨɜɤɟ ɮɭɧɤɰɢɢ.

f(int i, char n, int j) /* ɩɪɚɜɢɥɶɧɨ */ f(int i, k, float j) /* ɧɟɩɪɚɜɢɥɶɧɨ, ɞɥɹ ɩɟɪɟɦɟɧɧɨɣ k ɞɨɥɠɟɧ ɛɵɬɶ ɭɤɚɡɚɧ ɫɨɛɫɬɜɟɧɧɵɣ ɫɩɟɰɢɮɢɤɚɬɨɪ ɬɢɩɚ */

ɉɟɪɟɦɟɧɧɵɟ, ɨɩɪɟɞɟɥɟɧɧɵɟ ɜɧɭɬɪɢ ɮɭɧɤɰɢɢ, ɫɱɢɬɚɸɬɫɹ ɥɨɤɚɥɶɧɵɦɢ.

Ɉɞɧɚɤɨ ɟɫɬɶ ɢɫɤɥɸɱɟɧɢɟ ɢɡ ɷɬɨɝɨ ɩɪɚɜɢɥɚ – ɩɟɪɟɦɟɧɧɵɟ, ɨɛɴɹɜɥɟɧɧɵɟ ɫɨ ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ ɤɥɚɫɫɚ ɩɚɦɹɬɢ static.

ȼ ɋɢ ɫɭɳɟɫɬɜɭɟɬ ɞɜɚ ɫɩɨɫɨɛɚ ɩɟɪɟɞɚɱɢ ɩɚɪɚɦɟɬɪɨɜ ɜ ɮɭɧɤɰɢɢ – ɩɨ ɡɧɚɱɟ-

ɧɢɸ ɢ ɩɨ ɫɫɵɥɤɟ. Ⱦɥɹ ɩɟɪɟɞɚɱɢ ɩɨ ɫɫɵɥɤɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɭɤɚɡɚɬɟɥɢ.

ɉɪɢɦɟɪ 2.30. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɜ ɮɭɧɤɰɢɸ.

float funct(int x, float y, int *z) { float m = x*2 + y/4; float d = z*4; &z = 2; return m; }

ȼ ɞɚɧɧɨɦ ɩɪɢɦɟɪɟ ɩɚɪɚɦɟɬɪɵ x ɢ y ɩɟɪɟɞɚɸɬɫɹ ɩɨ

ɡɧɚɱɟɧɢɸ, ɚ ɩɚɪɚ-

ɦɟɬɪ z – ɩɨ ɫɫɵɥɤɟ.

ȿɫɥɢ ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɚ ɮɭɧɤɰɢɢ ɢɫɩɨɥɶɡɭɟɬɫɹ ɦɚɫɫɢɜ, ɬɨ ɮɭɧɤɰɢɢ ɩɟɪɟɞɚɟɬɫɹ ɟɝɨ ɚɞɪɟɫ. Ʉɚɤ ɦɵ ɜɵɹɫɧɢɥɢ ɪɚɧɟɟ, ɢɦɹ ɦɚɫɫɢɜɚ – ɷɬɨ ɭɤɚɡɚɬɟɥɶ ɧɚ ɟɝɨ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ, ɩɨɷɬɨɦɭ ɩɪɢ ɩɟɪɟɞɚɱɟ ɦɚɫɫɢɜɚ ɦɵ ɮɚɤɬɢɱɟɫɤɢ ɢɫɩɨɥɶɡɭɟɦ ɦɟɯɚɧɢɡɦ ɩɟɪɟɞɚɱɢ ɩɨ ɫɫɵɥɤɟ. ȼ ɷɬɨɦ ɢ ɫɨɫɬɨɢɬ ɢɫɤɥɸɱɟɧɢɟ ɩɨ ɨɬɧɨɲɟɧɢɸ

ɤ ɩɪɚɜɢɥɭ, ɤɨɬɨɪɨɟ ɝɥɚɫɢɬ, ɱɬɨ ɩɪɢ ɩɟɪɟɞɚɱɟ ɩɚɪɚɦɟɬɪɨɜ ɢɫɩɨɥɶɡɭɟɬɫɹ ɜɵɡɨɜ ɩɨ ɡɧɚɱɟɧɢɸ.

ɋɬɪɭɤɬɭɪɚ ɩɪɨɝɪɚɦɦɵ ɋɢ ɉɪɨɝɪɚɦɦɚ ɋɢ – ɷɬɨ ɨɩɪɟɞɟɥɟɧɢɟ ɮɭɧɤɰɢɢ main, ɤɨɬɨɪɚɹ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ

ɧɟɨɛɯɨɞɢɦɵɯ ɞɟɣɫɬɜɢɣ ɦɨɠɟɬ ɜɵɡɵɜɚɬɶ ɞɪɭɝɢɟ ɮɭɧɤɰɢɢ.

ɉɪɨɝɪɚɦɦɧɵɣ ɩɪɨɟɤɬ ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ ɧɟɫɤɨɥɶɤɨ ɮɚɣɥɨɜ, ɤɚɤ ɩɨɤɚɡɚɧɨ ɧɚ

ɪɢɫɭɧɤɟ 2.2.

Ɋɢɫɭɧɨɤ 2.2. ɉɪɨɝɪɚɦɦɚ ɋɢ, ɫɨɫɬɨɹɳɚɹ ɢɡ ɞɜɭɯ ɮɚɣɥɨɜ

ȼ ɩɪɢɦɟɪɟ, ɩɪɢɜɟɞɟɧɧɨɦ ɧɚ ɪɢɫɭɧɤɟ 2.2, ɮɭɧɤɰɢɹ main()ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɥɸɛɭɸ ɢɡ ɬɪɟɯ ɨɛɴɹɜɥɟɧɧɵɯ ɮɭɧɤɰɢɣ: func1(),func2() ɢ func3(). Ʌɸɛɚɹ ɮɭɧɤɰɢɹ ɢɡ ɭɤɚɡɚɧɧɵɯ ɬɪɟɯ ɦɨɠɟɬ ɬɚɤɠɟ ɜɵɡɜɚɬɶ ɞɪɭɝɭɸ ɮɭɧɤɰɢɸ, ɤɪɨɦɟ main(). Ɏɭɧɤɰɢɹ main ɦɨɠɟɬ ɛɵɬɶ ɜ ɩɪɨɝɪɚɦɦɧɨɦ ɩɪɨɟɤɬɟ ɬɨɥɶɤɨ ɜ ɟɞɢɧɫɬɜɟɧɧɨɦ ɱɢɫɥɟ!

Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɨɞɧɚ ɮɭɧɤɰɢɹ ɦɨɝɥɚ ɜɵɡɵɜɚɬɶ ɞɪɭɝɭɸ, ɨɧɚ ɞɨɥɠɧɚ

ɞɟɥɚɬɶ ɷɬɨ ɱɟɪɟɡ ɩɟɪɟɦɟɧɧɵɟ, ɩɪɢ ɷɬɨɦ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ ɩɟɪɟɦɟɧɧɵɟ ɞɨɥɠɧɵ ɢɦɟɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɤɥɚɫɫɵ ɩɚɦɹɬɢ (ɪɢɫ. 2.3).

Ɋɢɫɭɧɨɤ 2.3. Ʉɥɚɫɫɵ ɩɚɦɹɬɢ ɩɟɪɟɦɟɧɧɵɯ ɜ ɩɪɨɝɪɚɦɦɟ ɋɢ

ȼ ɩɪɨɝɪɚɦɦɚɯ ɋɢ ɦɨɝɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɤɥɚɫɫɵ ɩɚɦɹɬɢ static ɢ ex-

tern:

static int i=0; // ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɢɥɢ

static int i;

ɉɟɪɟɦɟɧɧɚɹ, ɢɫɩɨɥɶɡɭɸɳɚɹ ɤɥɚɫɫ ɩɚɦɹɬɢ extern, ɦɨɠɟɬ ɛɵɬɶ ɨɩɪɟɞɟɥɟɧɚ

ɧɚ ɜɧɟɲɧɟɦ ɭɪɨɜɧɟ ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ.

Ɂɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɩɨɞɤɥɸɱɚɸɬɫɹ ɫ ɩɨɦɨɳɶɸ ɞɢɪɟɤɬɢɜɵ #include. Ɉɧɢ ɨɛɵɱɧɨ ɢɦɟɸɬ ɪɚɫɲɢɪɟɧɢɟ *.h (ɩɟɪɜɚɹ ɛɭɤɜɚ ɫɥɨɜɚ header – ɚɧɝɥ. ɡɚɝɨɥɨɜɨɤ).

ȼ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ ɦɨɝɭɬ ɫɨɞɟɪɠɚɬɶɫɹ:

ɨɩɪɟɞɟɥɟɧɢɹ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɬɢɩɨɜ;



 ɨɩɢɫɚɧɢɹ ɩɪɨɬɨɬɢɩɨɜ ɮɭɧɤɰɢɣ;

 ɨɩɢɫɚɧɢɟ ɞɚɧɧɵɯ;

 ɨɩɪɟɞɟɥɟɧɢɟ ɤɨɧɫɬɚɧɬ;

 ɩɟɪɟɱɢɫɥɟɧɢɹ;

 ɞɢɪɟɤɬɢɜɵ #include;

 ɨɩɪɟɞɟɥɟɧɢɹ ɦɚɤɪɨɫɨɜ;

 ɤɨɦɦɟɧɬɚɪɢɢ.

Ⱦɢɪɟɤɬɢɜɚ #include ɩɨɞɤɥɸɱɚɟɬ ɤɨɩɢɸ ɭɤɚɡɚɧɧɨɝɨ ɜ ɞɢɪɟɤɬɢɜɟ ɮɚɣɥɚ ɜ ɬɨ ɦɟɫɬɨ ɩɪɨɝɪɚɦɦɵ, ɝɞɟ ɷɬɚ ɞɢɪɟɤɬɢɜɚ ɧɚɯɨɞɢɬɫɹ.

Ⱦɢɪɟɤɬɢɜɚ #include <ɢɦɹ_ɮɚɣɥɚ> ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɩɨɞɤɥɸɱɟɧɢɹ ɮɚɣɥɨɜ ɫɬɚɧɞɚɪɬɧɵɯ ɛɢɛɥɢɨɬɟɤ, ɧɚɩɪɢɦɟɪ:

#include <stdio.h>

Ⱦɢɪɟɤɬɢɜɚ

#include "ɢɦɹ_ɮɚɣɥɚ" ɩɪɢɦɟɧɹɟɬɫɹ ɞɥɹ ɩɨɞɤɥɸɱɟɧɢɹ

ɫɨɛɫɬɜɟɧɧɵɯ ɛɢɛɥɢɨɬɟɱɧɵɯ ɦɨɞɭɥɟɣ, ɧɚɩɪɢɦɟɪ:

#include

"mylib.h"

ȼ ɡɚɝɨɥɨɜɨɤ ɮɚɣɥɚ ɫ ɬɟɤɫɬɨɦ ɩɪɨɝɪɚɦɦɵ ɦɨɝɭɬ ɬɚɤɠɟ ɜɤɥɸɱɚɬɶɫɹ ɞɢɪɟɤɬɢɜɵ ɩɪɟɩɪɨɰɟɫɫɨɪɚ. ɉɪɟɩɪɨɰɟɫɫɨɪ – ɷɬɨ ɫɩɟɰɢɚɥɶɧɚɹ ɩɪɨɝɪɚɦɦɚ, ɨɫɭɳɟɫɬɜɥɹɸ-

ɳɚɹ ɩɪɟɞɜɚɪɢɬɟɥɶɧɭɸ ɨɛɪɚɛɨɬɤɭ ɬɟɤɫɬɚ ɩɪɨɝɪɚɦɦɵ.

Ⱦɢɪɟɤɬɢɜɚ #define ɫɥɭɠɢɬ ɞɥɹ ɫɨɡɞɚɧɢɹ ɤɨɧɫɬɚɧɬ ɢ ɦɚɤɪɨɫɨɜ (ɫɦ. ɩɪɢɦɟɪ 2.22). Ɏɨɪɦɚɬ ɡɚɩɢɫɢ:

#define ɂɦɹ_ɤɨɧɫɬɚɧɬɵ ɡɚɦɟɳɚɸɳɢɣ_ɬɟɤɫɬ

ȿɫɥɢ ɡɚɦɟɳɚɸɳɢɣ ɬɟɤɫɬ ɫɥɢɲɤɨɦ ɞɥɢɧɧɵɣ, ɟɝɨ ɦɨɠɧɨ ɩɟɪɟɧɟɫɬɢ ɧɚ ɫɥɟɞɭɸɳɭɸ ɫɬɪɨɤɭ,

ɜɜɟɞɹ ɫɢɦɜɨɥ «\».

ɉɨɫɥɟ ɡɚɩɢɫɢ ɬɚɤɨɣ ɫɬɪɨɤɢ ɜɫɟ ɜɫɬɪɟɬɢɜɲɢɟɫɹ ɞɚɥɟɟ ɜ ɬɟɤɫɬɟ ɩɪɨɝɪɚɦɦɵ ɢɦɟɧɚ, ɫɨɜɩɚɞɚɸɳɢɟ ɫ ɷɥɟɦɟɧɬɨɦ ɢɦɹ_ɤɨɧɫɬɚɧɬɵ, ɛɭɞɭɬ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɡɚɦɟɧɟɧɵ ɧɚ ɡɚɦɟɳɚɸɳɢɣ_ɬɟɤɫɬ ɩɪɟɠɞɟ, ɱɟɦ ɧɚɱɧɟɬɫɹ ɤɨɦɩɢɥɹɰɢɹ ɩɪɨɝɪɚɦɦɵ.

ɇɚɩɪɢɦɟɪ, ɞɢɪɟɤɬɢɜɚ

#define Pi 3.14159

ɨɩɪɟɞɟɥɹɟɬ ɤɨɧɫɬɚɧɬɭ Pi.

Ⱦɢɪɟɤɬɢɜɚ #undef ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɚɧɧɭɥɢɪɨɜɚɧɢɹ ɨɩɪɟɞɟɥɟɧɢɣ ɫɢɦɜɨɥɢɱɟɫɤɢɯ ɤɨɧɫɬɚɧɬ ɢ ɦɚɤɪɨɫɨɜ. Ɏɨɪɦɚɬ:

#undef ɢɞɟɧɬɢɮɢɤɚɬɨɪ

ɉɪɢɦɟɪ 2.31. Ⱦɢɪɟɤɬɢɜɵ define ɢ undef.

# define MyConst 128 // Ɉɩɪɟɞɟɥɟɧɢɟ ɤɨɧɫɬɚɧɬɵ

.....

Ⱦɪɭɝɢɟ ɨɩɟɪɚɬɨɪɵ ɩɪɨɝɪɚɦɦɵ

# undef MyConst // Ɉɬɦɟɧɚ ɨɩɪɟɞɟɥɟɧɢɹ

.....

Ⱦɪɭɝɢɟ ɨɩɟɪɚɬɨɪɵ ɩɪɨɝɪɚɦɦɵ

.....

# define MyConst 55 // ɇɨɜɨɟ ɨɩɪɟɞɟɥɟɧɢɟ

2.2.1. ɋɬɪɭɤɬɭɪɚ ɩɪɨɝɪɚɦɦɵ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ

2.2. Ɉɫɧɨɜɵ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ Ⱥɫɫɟɦɛɥɟɪ

ɉɪɨɝɪɚɦɦɚ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɫɨɫɬɨɢɬ ɢɡ ɫɥɟɞɭɸɳɢɯ ɨɫɧɨɜɧɵɯ ɪɚɡɞɟɥɨɜ, ɢɦɟɧɭɟɦɵɯ ɫɟɝɦɟɧɬɚɦɢ:

 ɫɟɝɦɟɧɬ ɫɬɟɤɚ (ɨɛɨɡɧɚɱɚɟɬɫɹ stack);

 ɫɟɝɦɟɧɬ ɤɨɞɚ (ɨɛɨɡɧɚɱɚɟɬɫɹ code);

 ɫɟɝɦɟɧɬ ɞɚɧɧɵɯ (ɨɛɨɡɧɚɱɚɟɬɫɹ data).

ɋɟɝɦɟɧɬ ɫɬɟɤɚ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɛɥɚɫɬɶ ɨɩɟɪɚɬɢɜɧɨɣ ɩɚɦɹɬɢ ɤɨɦɩɶɸɬɟɪɚ, ɨɬɜɟɞɟɧɧɨɣ ɩɨɞ ɫɬɟɤ. ɑɟɪɟɡ ɫɬɟɤ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɩɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɜ ɮɭɧɤɰɢɢ, ɜ ɧɟɦ ɠɟ ɯɪɚɧɹɬɫɹ ɪɚɡɥɢɱɧɵɟ ɫɥɭɠɟɛɧɵɟ

ɞɚɧɧɵɟ.

ɋɟɝɦɟɧɬ ɤɨɞɚ ɫɨɞɟɪɠɢɬ ɤɨɦɚɧɞɵ (ɨɩɟɪɚɬɨɪɵ) ɩɪɨɝɪɚɦɦ.

ɋɟɝɦɟɧɬ ɞɚɧɧɵɯ ɫɨɞɟɪɠɢɬ ɨɛɴɹɜɥɟɧɢɹ ɞɚɧɧɵɯ ɢ ɩɟɪɟɦɟɧɧɵɯ. Ɂɚɩɢɫɶ ɤɥɸ-

ɱɟɜɵɯ ɫɥɨɜ ɡɚɜɢɫɢɬ ɨɬ ɞɢɚɥɟɤɬɚ Ⱥɫɫɟɦɛɥɟɪɚ.

ȼ ɪɚɡɥɢɱɧɵɯ ɞɢɚɥɟɤɬɚɯ Ⱥɫɫɟɦɛɥɟɪɚ ɨɛɴɹɜɥɟɧɢɟ ɪɚɡɞɟɥɨɜ ɦɨɝɭɬ ɨɬɥɢɱɚɬɶɫɹ. ɇɢɠɟ ɩɪɢɜɟɞɟɧɵ ɩɪɢɦɟɪɵ ɞɥɹ ɩɪɨɝɪɚɦɦ TASM ɢ NASM.

ɉɪɢɦɟɪ 2.32. Ɉɛɴɹɜɥɟɧɢɟ ɪɚɡɞɟɥɨɜ ɜ Turbo Assembler.

.STACK 100h ; ɫɟɝɦɟɧɬ ɫɬɟɤɚ

.DATA ; ɫɟɝɦɟɧɬ ɞɚɧɧɵɯ

Message DB 'Hello World!',13,10,'$'

.CODE ; ɫɟɝɦɟɧɬ ɤɨɞɚ

mov ax,@Data

mov ds,ax

mov ah,9

......

END ; ɡɚɜɟɪɲɟɧɢɟ ɫɟɝɦɟɧɬɚ ɤɨɞɚ

ɉɪɢɦɟɪ 2.33. Ɉɛɴɹɜɥɟɧɢɟ ɪɚɡɞɟɥɨɜ ɜ NASM.

segment data

dvar: dw 1234

segment code

function: mov ax,data

inc word [dvar] ret

......

ȿɫɥɢ ɨɛɴɟɦ ɩɪɨɝɪɚɦɦɧɨɝɨ ɤɨɞɚ ɡɧɚɱɢɬɟɥɶɧɵɣ, ɩɪɨɝɪɚɦɦɭ ɪɚɡɞɟɥɹɸɬ ɧɚ ɱɚɫɬɢ (ɦɨɞɭɥɢ), ɤɨɬɨɪɵɟ ɡɚɩɢɫɵɜɚɸɬ ɜ ɨɬɞɟɥɶɧɵɟ ɮɚɣɥɵ. ɉɪɢ ɬɚɤɨɣ ɨɪɝɚɧɢɡɚɰɢɢ ɨɞɢɧ ɦɨɞɭɥɶ (ɮɚɣɥ) ɫɨɞɟɪɠɢɬ ɝɥɚɜɧɭɸ ɩɪɨɝɪɚɦɦɭ, ɚ ɜ ɞɪɭɝɢɯ ɦɨɞɭɥɹɯ ɪɚɡɦɟɳɟɧɵ ɩɨɞɩɪɨɝɪɚɦɦɵ.

Ɇɨɞɭɥɢ ɨɛɵɱɧɨ ɬɪɚɧɫɥɢɪɭɸɬ ɢ ɨɬɥɚɠɢɜɚɸɬ ɨɬɞɟɥɶɧɨ. Ɍɚɤɨɣ ɩɨɞɯɨɞ, ɜɨɩɟɪɜɵɯ, ɭɩɪɨɳɚɟɬ ɧɚɫɬɪɨɣɤɭ ɨɛɴɟɦɧɵɯ ɩɪɨɝɪɚɦɦ, ɢ, ɜɨ-ɜɬɨɪɵɯ

, ɩɨɡɜɨɥɹɟɬ ɫɨɡɞɚɜɚɬɶ ɛɢɛɥɢɨɬɟɤɢ ɩɨɞɩɪɨɝɪɚɦɦ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɞɪɭɝɢɯ ɩɪɨɟɤɬɚɯ.

Ʉɚɤ ɜɢɞɧɨ ɢɡ ɩɪɢɦɟɪɨɜ 2.32, 2.33, ɤɨɦɚɧɞɵ Ⱥɫɫɟɦɛɥɟɪɚ ɨɬɥɢɱɚɸɬɫɹ ɨɬ ɤɨɦɚɧɞ ɹɡɵɤɚ ɋɢ ɤɪɚɬɤɨɫɬɶɸ ɢ ɦɢɧɢɦɚɥɶɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɪɚɡɞɟɥɢɬɟɥɟɣ (ɡɚɩɹɬɵɯ, ɬɨɱɟɤ, ɫɤɨɛɨɤ ɢ ɬ. ɩ.).

2.2.2. ɋɢɧɬɚɤɫɢɫ ɤɨɦɚɧɞ Ⱥɫɫɟɦɛɥɟɪɚ

Ʉɨɦɚɧɞɚ (ɨɩɟɪɚɬɨɪ) ɜ ɩɪɨɝɪɚɦɦɟ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ ɫɢɧɬɚɤɫɢɫ:

[ɦɟɬɤɚ] ɤɨɦɚɧɞɚ [ɨɩɟɪɚɧɞ1 [, ɨɩɟɪɚɧɞ 2]]

Ⱦɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɹɫɧɢɬɶ ɡɧɚɱɟɧɢɹ ɤɨɦɚɧɞ, ɜ ɩɪɨɝɪɚɦɦɭ ɩɨɦɟɳɚɸɬ ɤɨɦɦɟɧɬɚɪɢɢ. Ʉɨɦɦɟɧɬɚɪɢɣ ɜ Ⱥɫɫɟɦɛɥɟɪɟ ɧɚɱɢɧɚɟɬɫɹ ɨɬ ɬɨɱɤɢ ɫ ɡɚɩɹɬɨɣ ɢ ɩɪɨɞɨɥɠɚɟɬɫɹ ɞɨ ɤɨɧɰɚ ɫɬɪɨɤɢ:

; ȼɵɜɨɞ ɫɨɨɛɳɟɧɢɹ ɧɚ ɷɤɪɚɧ

mov ah,9 ;ɮɭɧɤɰɢɹ DOS ɜɵɜɨɞɚ ɫɬɪɨɤɢ

Ɍɟɤɫɬ, ɧɚɯɨɞɹɳɢɣɫɹ ɫɩɪɚɜɚ

ɡɚ ɬɨɱɤɨɣ ɫ ɡɚɩɹɬɨɣ, ɹɜɥɹɟɬɫɹ ɤɨɦɦɟɧɬɚɪɢɟɦ,

ɤɨɬɨɪɵɣ ɬɪɚɧɫɥɹɬɨɪ ɢɝɧɨɪɢɪɭɟɬ.

Ʉɨɦɦɟɧɬɚɪɢɢ ɜ ɩɪɨɝɪɚɦɦɚɯ Ⱥɫɫɟɦɛɥɟɪɚ ɬɨɥɶɤɨ ɨɞɧɨɫɬɪɨɱɧɵɟ!

2.2.3. Ɍɢɩɵ ɞɚɧɧɵɯ ɢ ɩɟɪɟɦɟɧɧɵɟ

ȼ ɩɪɨɝɪɚɦɦɚɯ ɧɚ Ⱥɫɫɟɦɛɥɟɪɟ ɦɨɠɧɨ ɪɚɡɦɟɳɚɬɶ ɞɚɧɧɵɟ (ɱɢɫɥɚ, ɫɬɪɨɤɢ, ɚɞɪɟɫɚ) ɜ ɫɟɝɦɟɧɬɟ ɞɚɧɧɵɯ ɤɚɤ ɜ ɜɢɞɟ ɧɚɛɨɪɚ ɡɧɚɱɟɧɢɣ ɫ ɭɤɚɡɚɧɢɟɦ ɬɢɩɚ, ɬɚɤ ɢ ɜ ɜɢɞɟ ɢɦɟɧɨɜɚɧɧɵɯ ɩɟɪɟɦɟɧɧɵɯ.

Ɉɛɴɹɜɥɟɧɢɟ ɞɚɧɧɵɯ

ɢ ɩɟɪɟɦɟɧɧɵɯ ɧɚɱɢɧɚɟɬɫɹ ɫ ɬɢɩɚ ɞɚɧɧɵɯ, ɡɚ ɤɨɬɨɪɵɦ

ɫɥɟɞɭɸɬ ɡɧɚɱɟɧɢɹ.

Ɍɢɩ ɞɚɧɧɵɯ ɨɩɪɟɞɟɥɹɟɬ ɞɢɚɩɚɡɨɧ ɜɨɡɦɨɠɧɵɯ ɡɧɚɱɟɧɢɣ. Ɍɚɤ, ɞɥɹ DB ɜɨɡɦɨɠɧɵɟ ɡɧɚɱɟɧɢɹ ɥɟɠɚɬ ɩɪɟɞɟɥɚɯ ɨɬ 0 ɞɨ 2 ɞɨ 65535 (2

–1), ɢ ɬ. ɞ. Ɍɢɩɵ ɞɚɧɧɵɯ Ⱥɫɫɟɦɛɥɟɪɚ ɩɟɪɟɱɢɫɥɟɧɵ ɜ ɬɚɛɥɢɰɟ 2.5.

–1, ɬ. ɟ. ɨɬ 0 ɞɨ 255, ɞɥɹ DW – ɨɬ 0

ɪ,

Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 2.5

Ɍɢɩɵ ɞɚɧɧɵɯ Ⱥɫɫɟɦɛɥɟɪɚ

Ɍɢɩ ɞɚɧɧɵɯ Ɉɛɨɡɧɚɱɟɧɢɟ Ɋɚɡɦɟ

ɛɚɣɬ

Ȼɚɣɬ DB 1

ɋɥɨɜɨ DW 2

ɜɨɣɧɨɟ ɫɥɨɜɨ DD 4

ɑɟɬɜɟɪɧɨɟ ɫɥɨɜɨ D

ɟɥɨɟ, 10 ɛɚɣɬ DT 10

Ɏɨɪɦɚɬ ɨɛɴɹɜɥɟɧɢɹ ɩɟɪɟɦɟɧɧɨɣ ɜ Ⱥɫɫɟɦɛɥɟɪɟ ɫɥɟɞɭɸɳɢɣ:

[ɂɦɹ_ɩɟɪɟɦɟɧɧɨɣ] Ɍɢɩ Ɂɧɚɱɟɧɢɟ,

ɝɞɟ ɂɦɹ_ɩɟɪɟɦɟɧɧɨɣ – ɧɟɨɛɹɡɚɬɟɥɶɧɨɟ ɢɦɹ ɩɟɪɟɦɟɧɧɨɣ ɞɥɹ ɨɛɪɚɳɟɧɢɹ ɤ ɧɟɣ ɜ ɩɪɨɝɪɚɦɦɟ;

Ɍɢɩ – ɬɢɩ ɞɚɧɧɵɯ, ɯɪɚɧɹɳɢɣɫɹ ɜ ɩɟɪɟɦɟɧɧɨɣ (ɫɦ. ɬɚɛɥ. 2.5); Ɂɧɚɱɟɧɢɟ – ɱɢɫɥɨ ɢɥɢ ɫɬɪɨɤɚ.

ȿɫɥɢ Ɂɧɚɱɟɧɢɟ ɞɥɹ ɩɟɪɟɦɟɧɧɨɣ ɡɚɪɚɧɟɟ ɧɟ ɢɡɜɟɫɬɧɨ, ɦɨɠɧɨ ɜɦɟɫɬɨ ɧɟɝɨ ɡɚɩɢɫɚɬɶ ɡɧɚɤ ɜɨɩɪɨɫɚ ?, –

ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɞɥɹ ɩɟɪɟɦɟɧɧɨɣ ɛɭɞɟɬ ɜɵɞɟɥɟɧɚ ɩɚ-

ɦɹɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɨɛɴɟɦɚ.

Ʉɚɤ ɜɢɞɧɨ ɢɡ ɪɚɫɫɦɨɬɪɟɧɧɨɝɨ ɫɢɧɬɚɤɫɢɫɚ ɨɛɴɹɜɥɟɧɢɹ, ɢɦɹ ɩɟɪɟɦɟɧɧɨɣ ɧɟ ɹɜɥɹɟɬɫɹ ɧɟɨɛɯɨɞɢɦɵɦ ɚɬɪɢɛɭɬɨɦ (ɜ ɨɬɥɢɱɢɟ ɨɬ ɩɟɪɟɦɟɧɧɵɯ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ). ɗɬɨ ɨɛɴɹɫɧɹɟɬɫɹ ɬɟɦ, ɱɬɨ ɜ ɩɪɨɝɪɚɦɦɟ Ⱥɫɫɟɦɛɥɟɪɚ ɦɵ ɦɨɠɟɦ ɨɛɪɚɳɚɬɶɫɹ ɤ ɩɟɪɟɦɟɧɧɨɣ, ɭɤɚɡɚɜ ɟɟ ɢɦɹ, ɥɢɛɨ ɢɫɩɨɥɶɡɭɹ ɚɞɪɟɫ, ɩɨ ɤɨɬɨɪɨɦɭ

ɡɚɩɢɫɚɧɨ ɢɦɹ ɷɬɨɣ

ɩɟɪɟɦɟɧɧɨɣ ɜ ɩɚɦɹɬɢ ɤɨɦɩɶɸɬɟɪɚ.

ɉɪɢɦɟɪ 2.34. Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɵɯ ɜ Ⱥɫɫɟɦɛɥɟɪɟ.

VAR1 DB 44 msg DB ‘Hello, world!’, 0dh, 0ah, ‘$’ VAR22 DW ? X DW 10h ARR1 DB 30 DUP(?) ARR2 DB 10 DUP(11) MATR DW DUP(2 DUP(1));

ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɩɪɢɦɟɪɟ ɩɟɪɟɦɟɧɧɵɟ ɩɪɢɧɢɦɚɸɬ ɫɥɟɞɭɸɳɢɟ ɡɧɚɱɟɧɢɹ:

ɩɟɪɟɦɟɧɧɚɹ VAR1 ɫɨɞɟɪɠɢɬ ɰɟɥɨɟ ɱɢɫɥɨ 44;

ɩɟɪɟɦɟɧɧɚɹ msg ɫɨɞɟɪɠɢɬ ɫɬɪɨɤɭ 'Hello, world'. ɋɢɦɜɨɥɵ 0dh, 0ah ɨɡɧɚɱɚɸɬ ɩɟɪɟɯɨɞ ɧɚ ɧɨɜɭɸ ɫɬɪɨɤɭ, ɚ ɫɩɟɰɫɢɦɜɨɥ $ ɡɚɜɟɪɲɚɟɬ ɫɬɪɨɤɭ;

ɩɟɪɟɦɟɧɧɚɹ VAR22 ɬɢɩɚ «ɫɥɨɜɨ» ɢɡɧɚɱɚɥɶɧɨ ɧɟ ɫɨɞɟɪɠɢɬ ɡɧɚɱɟɧɢɹ

(

ɩɭ-

ɫɬɚɹ);

ɩɟɪɟɦɟɧɧɚɹ X ɫɨɞɟɪɠɢɬ ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɟ ɡɧɚɱɟɧɢɟ 10h;

ɩɟɪɟɦɟɧɧɵɟ ARR1, ARR2, MATR

– ɷɬɨ ɦɚɫɫɢɜɵ, ɫɨɞɟɪɠɚɳɢɟ, ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ,

30, 10 ɢ 4 ɷɥɟɦɟɧɬɚ. ɉɪɢ ɷɬɨɦ ɦɚɫɫɢɜ ARR1 ɧɟ ɫɨɞɟɪɠɢɬ ɧɚɱɚɥɶɧɵɯ ɡɧɚɱɟɧɢɣ,

ɦɚɫɫɢɜ ARR2 ɡɚɩɨɥɧɹɟɬɫɹ ɱɢɫɥɚɦɢ 11, ɚ ɦɚɫɫɢɜ MATR ɡɚɩɨɥɧɟɧ ɟɞɢɧɢɰɚɦɢ.

Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɨɫɨɛɟɧɧɨɫɬɢ ɨɛɴɹɜɥɟɧɢɹ ɫɬɪɨɤɨɜɨɣ ɩɟɪɟɦɟɧɧɨɣ msg, ɚ ɬɚɤɠɟ ɦɚɫɫɢɜɨɜ ARR1, ARR2, MATR. Ɍɚɤ ɤɚɤ ɷɬɢ ɩɟɪɟɦɟɧɧɵɟ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɝɪɭɩɩɭ ɛɚɣɬɨɜ, ɬɨ ɢɯ ɢɦɟɧɚ – ɷɬɨ ɫɫɵɥɤɢ ɧɚ

ɩɟɪɜɵɣ ɛɚɣɬ ɜ ɝɪɭɩɩɟ.

2.2.4. ɉɟɪɟɫɵɥɤɚ, ɚɞɪɟɫɚɰɢɹ ɢ ɨɛɦɟɧ ɞɚɧɧɵɦɢ

Ɋɚɫɫɦɨɬɪɢɦ ɨɞɧɭ ɢɡ ɧɚɢɛɨɥɟɟ ɱɚɫɬɨ ɭɩɨɬɪɟɛɥɹɟɦɵɯ ɤɨɦɚɧɞ ɹɡɵɤɚ Ⱥɫɫɟɦɛɥɟɪ – ɤɨɦɚɧɞɭ ɩɟɪɟɫɵɥɤɢ ɞɚɧɧɵɯ MOV. ȿɟ ɧɚɡɧɚɱɟɧɢɟ – ɩɟɪɟɫɵɥɤɚ ɞɚɧɧɵɯ ɢɡ ɨɞɧɨɝɨ ɪɟɝɢɫɬɪɚ ɜ ɞɪɭɝɨɣ, ɢ ɢɡ ɪɟɝɢɫɬɪɚ – ɜ ɩɚɦɹɬɶ ɤɨɦɩɶɸɬɟɪɚ.

ɋɢɧɬɚɤɫɢɫ ɤɨɦɚɧɞɵ MOV ɫɥɟɞɭɸɳɢɣ:

MOV ɩɪɢɟɦɧɢɤ, ɢɫɬɨɱɧɢɤ,

ɝɞɟ ɩɪɢɟɦɧɢɤ – ɪɟɝɢɫɬɪ ɢɥɢ ɹɱɟɣɤɚ ɩɚɦɹɬɢ (ɩɟɪɟɦɟɧɧɚɹ), ɜ ɤɨɬɨɪɭɸ

ɩɟɪɟɫɵ-

ɥɚɸɬɫɹ ɞɚɧɧɵɟ;

ɢɫɬɨɱɧɢɤ – ɪɟɝɢɫɬɪ ɢɥɢ ɹɱɟɣɤɚ ɩɚɦɹɬɢ (ɩɟɪɟɦɟɧɧɚɹ), ɢɡ ɤɨɬɨɪɨɣ ɩɟɪɟɫɵɥɚɸɬɫɹ ɞɚɧɧɵɟ.

ɉɪɢɦɟɪ 2.35. ɉɟɪɟɫɵɥɤɚ ɞɚɧɧɵɯ ɤɨɦɚɧɞɨɣ MOV.

MOV AX, BX ; AX <- BX MOV ES, AX ; ES <- AX MOV AX, 10 ; AX <- 10 MOV EAX, 0FFFFH; EAX <-0FFFFH

ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɤɨɦɚɧɞɵ MOV ɧɟɨɛɯɨɞɢɦɨ ɭɱɢɬɵɜɚɬɶ ɫɥɟɞɭɸɳɢɟ ɨɝɪɚɧɢɱɟɧɢɹ:

1. ɇɟɥɶɡɹ ɩɟɪɟɫɵɥɚɬɶ ɞɚɧɧɵɟ ɢɡ ɨɞɧɨɣ ɨɛɥɚɫɬɢ ɩɚɦɹɬɢ

ɜ ɞɪɭɝɭɸ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ. ɗɬɨ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɬɨɥɶɤɨ ɱɟɪɟɡ ɪɟɝɢɫɬɪɵ ɨɛɳɟɝɨ ɧɚɡɧɚɱɟɧɢɹ, ɧɚɩɪɢɦɟɪ, ɬɚɤ:

VAR1 DB 11 ; Ɉɛɴɹɜɥɹɟɦ ɞɜɟ ɩɟɪɟɦɟɧɧɵɟ VAR2 DB 55 ;

.....

MOV AL, VAR1 ; ɉɟɪɟɫɵɥɚɟɦ ɞɚɧɧɵɟ ɢɡ VAR1 ɜ AL MOV VAR2, AL ; Ɍɟɩɟɪɶ ɢɡ AL ɜ VAR2 ; ɉɨɫɥɟ ɨɩɟɪɚɰɢɢ: VAR1 = 11 VAR2 = 11

ɇɟɥɶɡɹ ɩɨɦɟɳɚɬɶ ɞɚɧɧɵɟ ɢɡ ɩɚɦɹɬɢ ɜ ɫɟɝɦɟɧɬɧɵɟ ɪɟɝɢɫɬɪɵ. Ʉɚɤ ɢ ɜ ɩɪɟɞɵɞɭɳɟɦ ɫɥɭɱɚɟ, ɷɬɨ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɱɟɪɟɡ ɪɟɝɢɫɬɪɵ ɨɛɳɟɝɨ ɧɚɡɧɚɱɟɧɢɹ (ɊɈɇ):

MOV ax, VAR MOV ds, ax

3. ɇɟɥɶɡɹ ɩɪɨɢɡɜɨɞɢɬɶ ɩɟɪɟɫɵɥɤɭ ɞɚɧɧɵɯ ɢɡ ɨɞɧɨɝɨ ɫɟɝɦɟɧɬɧɨɝɨ ɪɟɝɢɫɬɪɚ

ɜ ɞɪɭɝɨɣ ɧɚɩɪɹɦɭɸ, ɬɨɥɶɤɨ ɱɟɪɟɡ ɊɈɇ:

MOV ax, es MOV ds, ax

4. ɇɟɥɶɡɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɟɝɦɟɧɬɧɵɣ ɪɟɝɢɫɬɪ CS ɜ ɤɚɱɟɫɬɜɟ ɩɪɢɟɦɧɢɤɚ, ɬɚɤ

ɤɚɤ ɜ ɩɚɪɟ ɪɟɝɢɫɬɪɨɜ CS:IP ɫɨɞɟɪɠɢɬɫɹ ɚɞɪɟɫ ɫɥɟɞɭɸɳɟɣ ɤɨɦɚɧɞɵ.

Ʉ ɤɨɦɚɧɞɚɦ ɩɟɪɟɫɵɥɤɢ ɞɚɧɧɵɯ ɨɬɧɨɫɢɬɫɹ ɬɚɤɠɟ ɤɨɦɚɧɞɚ ɨɛɦɟɧɚ XCHG (exchange). Ɉɧɚ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ ɫɢɧɬɚɤɫɢɫ:

XCHG ɨɩɟɪɚɧɞ1, ɨɩɟɪɚɧɞ

ɝɞɟ ɨɩɟɪɚɧɞ1, ɨɩɟɪɚɧɞ2 – ɪɟɝɢɫɬɪ ɢɥɢ ɹɱɟɣɤɚ ɩɚɦɹɬɢ.

<<< < Предыдущая 1 2 3 45 / 205 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 > Следующая >>>

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]