Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
ɉɪɚɜɢɥɨ 3. ɍɤɚɡɚɬɟɥɶ ɧɟɥɶɡɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɯɪɚɧɟ-
ɧɢɹ ɪɟɡɭɥɶɬɚɬɚ ɜɵɩɨɥɧɟɧɢɹ ɨɩɟɪɚɰɢɢ:
float *fptr;
float f1 = 12.3, f2 = 89.05, f3;
fptr = &(f1/f2); // ɇɟɜɟɪɧɨ
f3 = f1/f2;
fptr = &f3; // ȼɟɪɧɨ
Ɉɫɨɛɨ ɨɬɦɟɬɢɦ ɨɩɟɪɚɬɨɪɵ * (ɨɩɟɪɚɬɨɪ ɪɚɡɵɦɟɧɨɜɚɧɢɹ) ɢ & (ɨɩɟɪɚɬɨɪ ɩɨɥɭɱɟɧɢɹ ɚɞɪɟɫɚ), ɤɨɬɨɪɵɟ ɛɵɥɢ ɢɫɩɨɥɶɡɨɜɚɧɵ ɧɚɦɢ ɜ ɩɪɢɜɟɞɟɧɧɵɯ ɩɪɢɦɟɪɚɯ.
Ɉɩɟɪɚɬɨɪ ɪɚɡɵɦɟɧɨɜɚɧɢɹ * ɩɟɪɟɞ ɩɟɪɟɦɟɧɧɨɣ-ɭɤɚɡɚɬɟɥɟɦ ɩɨɡɜɨɥɹɟɬ ɩɨɥɭɱɢɬɶ ɡɧɚɱɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ, ɧɚ ɤɨɬɨɪɭɸ ɭɤɚɡɵɜɚɟɬ ɭɤɚɡɚɬɟɥɶ. Ɉɩɟɪɚɬɨɪ ɩɨɥɭ
ɱɟɧɢɹ ɚɞɪɟɫɚ & ɩɨɡɜɨɥɹɟɬ ɩɪɢɫɜɨɢɬɶ ɩɟɪɟɦɟɧɧɨɣ-ɭɤɚɡɚɬɟɥɸ ɚɞɪɟɫ ɤɚɤɨɣ-ɥɢɛɨ
ɩɟɪɟɦɟɧɧɨɣ.
Ɋɚɫɫɦɨɬɪɢɦ ɟɳɟ ɨɞɢɧ ɩɪɢɦɟɪ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɪɚɡɨɛɪɚɬɶɫɹ ɜ ɬɨɦ, ɤɚɤ ɪɚɛɨɬɚɸɬ ɭɤɚɡɚɬɟɥɢ.
ɉɪɢɦɟɪ 2.9. Ɉɫɨɛɟɧɧɨɫɬɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɭɤɚɡɚɬɟɥɟɣ.
int v1 = 0, *p1, *p2;
p1 = &v1; // p1 ɭɤɚɡɵɜɚɟɬ ɧɚ v1
*p1 = 42; // ɉɪɢɫɜɨɢɬɶ ɩɟɪɟɦɟɧɧɨɣ v1
// ɡɧɚɱɟɧɢɟ ɱɟɪɟɡ p1
printf(v1); // ȼɵɜɟɞɟɬ 42
printf(p1); // ȼɵɜɟɞɟɬ 42
p2 = p1; // Ɍɟɩɟɪɶ p2 ɭɤɚɡɵɜɚɟɬ ɧɚ ɬɭ
// ɠɟ ɹɱɟɣɤɭ ɩɚɦɹɬɢ, ɱɬɨ ɢ p1
printf(*p2); //
ȼɵɜɟɞɟɬ 42
v1 = 55; // ɉɨɦɟɧɹɟɦ v1
*p2 = *p1;
printf(*p2); // ȼɵɜɟɞɟɬ 55
Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɟɫɥɢ p1 ɢ p2 – ɩɟɪɟɦɟɧɧɵɟ-ɭɤɚɡɚɬɟɥɢ, ɬɨ ɢɧɫɬɪɭɤɰɢɹ ɜɢɞɚ p1 = p2 ɢɡɦɟɧɹɟɬ ɡɧɚɱɟɧɢɟ p1 ɬɚɤ, ɱɬɨ ɷɬɚ ɩɟɪɟɦɟɧɧɚɹ ɭɤɚɡɵɜɚɟɬ ɧɚ ɬɨ
ɠɟ ɦɟɫɬɨ ɜ ɩɚɦɹɬɢ, ɱɬɨ ɢ p2.
ɋ ɭɤɚɡɚɬɟɥɹɦɢ ɜ ɋɢ ɦɨɠɧɨ ɜɵɩɨɥɧɹɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ:
ɩɪɢɫɜɚɢɜɚɧɢɟ;
ɫɥɨɠɟɧɢɟ ɫ ɱɢɫɥɨɦ;
ɜɵɱɢɬɚɧɢɟ;
ɨɩɟɪɚɰɢɹ
ɢɧɤɪɟɦɟɧɬɚ (ɩɪɢɪɚɳɟɧɢɹ);
ɨɩɟɪɚɰɢɹ ɞɟɤɪɟɦɟɧɬɚ (ɭɦɟɧɶɲɟɧɢɟ);
ɨɩɟɪɚɰɢɹ ɜɵɱɢɫɥɟɧɢɹ ɪɚɡɦɟɪɚ sizeof();
ɫɪɚɜɧɟɧɢɟ ɭɤɚɡɚɬɟɥɟɣ (<, >, <=, >=, ==, !=).
ɇɟɞɨɩɭɫɬɢɦɵɟ ɨɩɟɪɚɰɢɢ:
ɫɥɨɠɟɧɢɟ ɭɤɚɡɚɬɟɥɟɣ;
ɭɦɧɨɠɟɧɢɟ ɭɤɚɡɚɬɟɥɟɣ;
ɞɟɥɟɧɢɟ ɨɞɧɨɝɨ ɭɤɚɡɚɬɟɥɹ ɧɚ ɞɪɭɝɨɣ.
-
31
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɨɠɧɵɟ ɬɢɩɵ ɞɚɧɧɵɯ ɹɡɵɤɚ ɋɢ.
Ɇɚɫɫɢɜ – ɷɬɨ ɧɚɛɨɪ ɩɟɪɟɦɟɧɧɵɯ ɨɞɧɨɝɨ ɬɢɩɚ, ɢɦɟɸɳɢɯ ɢɦɹ ɢ ɫɧɚɛɠɟɧɧɵɯ
ɢɧɞɟɤɫɚɦɢ. Ⱦɨɫɬɭɩ ɤ ɤɨɧɤɪɟɬɧɨɦɭ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɫ ɩɨɦɨɳɶɸ ɢɧɞɟɤɫɚ. ɇɭɦɟɪɚɰɢɹ ɷɥɟɦɟɧɬɨɜ ɦɚɫɫɢɜɚ ɧɚɱɢɧɚɟɬɫɹ ɫ ɧɭɥɹ.
ɋɢɧɬɚɤɫɢɫ ɨɛɴɹɜɥɟɧɢɹ ɨɞɧɨɦɟɪɧɨɝɨ ɦɚɫɫɢɜɚ:
ɬɢɩ ɢɦɹ_ɩɟɪɟɦɟɧɧɨɣ_ɦɚɫɫɢɜɚ [ɪɚɡɦɟɪ];
Ɂɞɟɫɶ ɬɢɩ ɨɛɨɡɧɚɱɚɟɬ ɬɢɩ ɷɥɟɦɟɧɬɨɜ ɦɚɫɫɢɜɚ, ɪɚɡɦɟɪ ɡɚɞɚɟɬ
ɤɨɥɢɱɟɫɬɜɨ
ɷɥɟɦɟɧɬɨɜ ɦɚɫɫɢɜɚ. ɇɚɩɪɢɦɟɪ, ɫɥɟɞɭɸɳɢɣ ɨɩɟɪɚɬɨɪ ɨɛɴɹɜɥɹɟɬ ɦɚɫɫɢɜ ɢɡ 50 ɷɥɟɦɟɧɬɨɜ ɰɟɥɨɝɨ ɬɢɩɚ ɫ ɢɦɟɧɟɦ array:
int array[50];
Ⱦɨɫɬɭɩ ɤ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɫ ɩɨɦɨɳɶɸ ɢɦɟɧɢ ɦɚɫɫɢɜɚ ɢ
ɢɧɞɟɤɫɚ. ɂɧɞɟɤɫ ɷɥɟɦɟɧɬɚ ɦɚɫɫɢɜɚ ɩɨɦɟɳɚɟɬɫɹ ɜ ɤɜɚɞɪɚɬɧɵɯ ɫɤɨɛɤɚɯ ɩɨɫɥɟ
ɢɦɟɧɢ. Ɉɩɟɪɚɬɨɪ array[2] = -6; ɩɪɢɫɜɚɢɜɚɟɬ 3-ɦɭ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ar-
ray ɡɧɚɱɟɧɢɟ –6.
ɋɢɧɬɚɤɫɢɫ ɨɛɴɹɜɥɟɧɢɹ ɦɧɨɝɨɦɟɪɧɨɝɨ ɦɚɫɫɢɜɚ:
ɬɢɩ ɢɦɹ_ɦɚɫɫɢɜɚ
[Ɋɚɡɦɟɪ1][Ɋɚɡɦɟɪ2]...[Ɋɚɡɦɟɪ n];
Ɇɚɫɫɢɜɵ ɦɨɠɧɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɩɪɢ ɨɛɴɹɜɥɟɧɢɢ:
ɬɢɩ ɂɦɹMaccuea[paɡɦep1]...[paɡɦepN] =
{ɫɩɢɫɨɤ_ɡɧɚɱɟɧɢɣ};
ɢɥɢ ɜ ɩɪɨɝɪɚɦɦɟ
ɂɦɹMaccuBa[ɢɧɞɟɤɫ1]...[ɢɧɞɟɤɫN] = Ɂɧɚɱɟɧɢɟ;
ɋɩɢɫɨɤ_ɡɧɚɱɟɧɢɣ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɧɚɛɨɪ ɡɧɚɱɟɧɢɣ, ɪɚɡɞɟɥɟɧɧɵɯ
ɡɚɩɹɬɵɦɢ. Ɍɢɩɵ ɡɧɚɱɟɧɢɣ ɞɨɥɠɧɵ ɛɵɬɶ ɫɨɜɦɟɫɬɢɦɵɦɢ ɫ ɬɢɩɨɦ ɷɥɟɦɟɧɬɨɜ ɦɚɫɫɢɜɚ. ɇɢɠɟ ɩɨɤɚɡɚɧ ɩɪɢɦɟɪ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɨɞɧɨɦɟɪɧɨɝɨ ɢ ɞɜɭɯɦɟɪɧɨɝɨ ɦɚɫɫɢɜɨɜ ɩɪɢ ɢɯ
ɨɛɴɹɜɥɟɧɢɢ.
ɉɪɢɦɟɪ 2.10. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɦɚɫɫɢɜɨɜ ɩɪɢ ɨɛɴɹɜɥɟɧɢɢ.
// ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɨɞɧɨɦɟɪɧɨɝɨ ɦɚɫɫɢɜɚ
int i[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɞɜɭɯɦɟɪɧɨɝɨ ɦɚɫɫɢɜɚ:
int arr[10][2] = {{1, 1}, {2, 2}, {3, 4},
{4, 5}, {6, -7}, {6, 0},
{7, -11}, {0, 6}, {-22, 11},
{10, 20} };
ɂɞɟɧɬɢɮɢɤɚɬɨɪ ɦɚɫɫɢɜɚ ɫɨɞɟɪɠɢɬ ɚɞɪɟɫ ɩɟɪɜɨɝɨ ɷɥɟɦɟɧɬ ɦɚɫɫɢɜɚ, ɩɪɢɱɟɦ ɷɬɨ ɚɞɪɟɫ ɩɨɫɬɨɹɧɧɵɣ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɦɨɠɧɨ ɝɨɜɨɪɢɬɶ ɨ ɬɨɦ, ɱɬɨ ɢɞɟɧɬɢɮɢɤɚɬɨɪ ɦɚɫɫɢɜɚ – ɷɬɨ ɭɤɚɡɚɬɟɥɶ.
Ɉɛɴɹɜɢɦ ɞɜɟ ɩɟɪɟɦɟɧɧɵɟ:
int E_int[10];
int *ar_ptr;
ɂɧɢɰɢɚɥɢɡɢɪɭɟɦ ɩɟɪɟɦɟɧɧɭɸ-ɭɤɚɡɚɬɟɥɶ, ɩɪɢɫɜɨɢɜ ɟɣ ɡɧɚɱɟɧɢɟ
ɚɞɪɟɫɚ
ɩɟɪɜɨɝɨ ɷɥɟɦɟɧɬɚ ɦɚɫɫɢɜɚ:
ar_ptr = E_int;
ɗɬɨ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɢ ɬɚɤ:
ar_ptr = &E_int[0];
32
Ⱦɥɹ ɷɬɨɝɨ, ɱɬɨɛɵ ɨɛɪɚɬɢɬɶɫɹ ɤ ɨɱɟɪɟɞɧɨɦɭ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɶ, ɧɭɠɧɨ ɫɞɟɥɚɬɶ ɩɪɢɪɚɳɟɧɢɟ ɚɞɪɟɫɚ ɭɤɚɡɚɬɟɥɹ. Ɋɚɫɫɦɨɬɪɢɦ ɷɬɨ ɧɚ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 2.11. ɋɩɨɫɨɛɵ ɨɛɪɚɳɟɧɢɹ ɤ ɦɚɫɫɢɜɭ.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int D[5] = {1,2,3,4,5};
int *ar_ptr;
void main() {
ar_ptr = D; int i;
for (i=0; i<5;i++)
printf("D[%d]=%d\n", i,D[i]);
printf("D+2=%d\n", *(D+2)); // 3
printf("ar_ptr[2] = %d\n", ar_ptr[2]); // 3
printf("3[ar_ptr] = %d\n", 3[ar_ptr]); // 4
printf("3[D] = %d\n", 3[D]); // 4
getch(); }
ɉɪɨɚɧɚɥɢɡɢɪɭɟɦ ɷɬɨɬ ɩɪɢɦɟɪ (ɚ ɢɦɟɧɧɨ ɬɟɥɨ ɮɭɧɤɰɢɢ main).
ȼ ɩɟɪɜɨɣ ɫɬɪɨɤɟ ɚɞɪɟɫ ɩɟɪɜɨɝɨ ɷɥɟɦɟɧɬɚ ɦɚɫɫɢɜɚ D ɩɪɢɫɜɚɢɜɚɟɬɫɹ ɭɤɚɡɚ-
ɬɟɥɸ
ar_ptr.
ȼɨ ɜɬɨɪɨɣ ɢ ɬɪɟɬɶɟɣ ɫɬɪɨɤɟ ɜ ɰɢɤɥɟ ɷɥɟɦɟɧɬɵ ɦɚɫɫɢɜɚ ɜɵɜɨɞɹɬɫɹ
ɧɚ ɷɤɪɚɧ. Ɂɞɟɫɶ ɢɫɩɨɥɶɡɭɟɬɫɹ ɨɛɵɱɧɚɹ ɚɞɪɟɫɚɰɢɹ – ɨɛɪɚɳɟɧɢɟ ɩɨ ɢɧɞɟɤɫɭ.
ȼ ɱɟɬɜɟɪɬɨɣ ɫɬɪɨɤɟ ɦɵ ɨɛɪɚɳɚɟɦɫɹ ɤ ɦɚɫɫɢɜɭ ɱɟɪɟɡ ɚɞɪɟɫ (D + 2). ɗɬɨ
ɨɡɧɚɱɚɟɬ, ɱɬɨ ɦɵ ɜɵɜɨɞɢɦ ɧɚ ɷɤɪɚɧ ɫɨɞɟɪɠɢɦɨɟ ɷɥɟɦɟɧɬɚ ɦɚɫɫɢɜɚ, ɚɞɪɟɫ ɤɨɬɨɪɨɝɨ ɪɚɜɟɧ D+2 = 0+2 = 2. ɗɬɚ ɹɱɟɣɤɚ ɫɨɞɟɪɠɢɬ ɱɢɫɥɨ 3. ȼ
ɩɹɬɨɣ ɫɬɪɨɤɟ ɦɵ
ɨɛɪɚɳɚɟɦɫɹ ɤ ɬɨɣ ɠɟ ɹɱɟɣɤɟ, ɧɨ ɱɟɪɟɡ ɩɟɪɟɦɟɧɧɭɸ-ɭɤɚɡɚɬɟɥɶ. ȼ ɲɟɫɬɨɣ ɢ ɫɟɞɶɦɨɣ ɫɬɪɨɤɚɯ ɩɨɤɚɡɚɧɵ ɜɚɪɢɚɧɬɵ ɨɛɪɚɳɟɧɢɹ ɤ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɶ
ɢ ɩɟɪɟɦɟɧɧɭɸ.
Ɍɟɩɟɪɶ ɪɚɫɫɦɨɬɪɢɦ ɨɛɪɚɳɟɧɢɟ ɤ ɬɪɟɯɦɟɪɧɨɦɭ ɦɚɫɫɢɜɭ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɢ.
Ⱦɚɧ ɬɪɟɯɦɟɪɧɵɣ ɦɚɫɫɢɜ ɢ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟɝɨ:
int arr[L][M][N]; int *ptr;
ptr = &arr[0][0][0];
Ɍɟɩɟɪɶ ɪɚɫɫɦɨɬɪɢɦ ɜɵɪɚɠɟɧɢɹ:
Ptr ɭɤɚɡɵɜɚɟɬ ɧɚ ɷɥɟɦɟɧɬ
ɫ
ɢɧɞɟɤɫɨɦ 0,0,0 ɜ ɦɚɫɫɢɜɟ arr
ptr+i*(M*N)+j*N ɚɞɪɟɫ j-ɣ ɫɬɪɨɤɢ i-ɝɨ ɦɚɫɫɢɜɚ ɪɚɡɦɟɪɨɦ MxN ɜ ɦɚɫɫɢ-
ɜɟ arr
*(ptr+i*(M*N)+j*N*K) k-ɣ ɷɥɟɦɟɧɬ j-ɣ ɫɬɪɨɤɢ i-ɝɨ ɦɚɫɫɢɜɚ MxN ɜ
ɦɚɫɫɢɜɟ arr
ȼɚɠɧɵɦ ɷɥɟɦɟɧɬɨɦ ɥɸɛɨɝɨ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɹɜɥɹɸɬɫɹ ɫɬɪɨɤɢ,
ɩɨɡɜɨɥɹɸɳɢɟ ɜɵɜɨɞɢɬɶ ɫɨɨɛɳɟɧɢɹ, ɚ ɬɚɤɠɟ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɭɧɢɜɟɪɫɚɥɶɧɵɟ ɩɪɨɰɟɞɭɪɵ ɜɜɨɞɚ ɞɚɧɧɵɯ.
ɋɬɪɨɤɚ – ɷɬɨ ɨɞɧɨɦɟɪɧɵɣ ɦɚɫɫɢɜ ɫɢɦɜɨɥɨɜ, ɡɚɤɚɧɱɢɜɚɸɳɢɣɫɹ
ɧɭɥɟɜɵɦ
ɫɢɦɜɨɥɨɦ. ȼ ɹɡɵɤɟ ɋɢ ɩɪɢɡɧɚɤɨɦ ɨɤɨɧɱɚɧɢɹ ɫɬɪɨɤɢ (ɬ. ɧ. «ɧɭɥɟɜɵɦ ɫɢɦɜɨɥɨɦ») ɫɥɭɠɢɬ ɫɢɦɜɨɥ '\0'. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɬɪɨɤɚ ɫɨɞɟɪɠɢɬ ɫɢɦɜɨɥɵ – ɷɥɟɦɟɧ-
33
ɬɵ ɫɬɪɨɤɢ, ɚ ɬɚɤɠɟ ɧɭɥɟɜɨɣ ɫɢɦɜɨɥ. Ɏɭɧɤɰɢɢ ɞɥɹ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɤɚɦɢ ɨɩɪɟɞɟɥɟɧɵ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ string.h (ɫɦ. ɉɪɢɥɨɠɟɧɢɟ Ⱥ).
Ɉɛɴɹɜɥɹɹ ɦɚɫɫɢɜ ɫɢɦɜɨɥɨɜ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɣ ɞɥɹ ɯɪɚɧɟɧɢɹ ɫɬɪɨɤɢ, ɧɟɨɛɯɨɞɢɦɨ ɩɪɟɞɭɫɦɨɬɪɟɬɶ ɦɟɫɬɨ ɞɥɹ ɫɢɦɜɨɥɚ '\0', ɬ. ɟ. ɭɤɚɡɚɬɶ ɟɝɨ ɪɚɡɦɟɪ ɧɚ ɨɞɢɧ
ɫɢɦɜɨɥ ɛɨɥɶɲɟ, ɱɟɦ ɧɚɢɛɨɥɶɲɟɟ ɩɪɟɞɩɨɥɚɝɚɟɦɨɟ ɤɨɥɢɱɟɫɬɜɨ ɫɢɦɜɨɥɨɜ.
ɇɚɩɪɢɦɟɪ, ɨɛɴɹɜɥɟɧɢɟ ɦɚɫɫɢɜɚ
str, ɩɪɟɞɧɚɡɧɚɱɟɧɧɨɝɨ ɞɥɹ ɯɪɚɧɟɧɢɹ ɫɬɪɨɤɢ
ɢɡ 10 ɫɢɦɜɨɥɨɜ, ɞɨɥɠɧɨ ɜɵɝɥɹɞɟɬɶ ɬɚɤ: char str[11]. ɉɨɫɥɟɞɧɢɣ, 11-ɣ ɛɚɣɬ
ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɧɭɥɟɜɨɝɨ ɫɢɦɜɨɥɚ.
Ɂɚɩɢɫɚɧɧɚɹ ɜ ɬɟɤɫɬɟ ɩɪɨɝɪɚɦɦɵ ɫɬɪɨɤɚ ɫɢɦɜɨɥɨɜ, ɡɚɤɥɸɱɟɧɧɵɯ ɜ ɞɜɨɣɧɵɟ
ɤɚɜɵɱɤɢ, ɹɜɥɹɟɬɫɹ ɫɬɪɨɤɨɜɨɣ ɤɨɧɫɬɚɧɬɨɣ, ɧɚɩɪɢɦɟɪ: "ɧɟɤɨɬɨɪɚɹ ɫɬɪɨɤɚ".
ȼ ɤɨɧɟɰ ɫɬɪɨɤɨɜɨɣ ɤɨɧɫɬɚɧɬɵ ɤɨɦɩɢɥɹɬɨɪ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɞɨɛɚɜɥɹɟɬ ɧɭɥɟ-
ɜɨɣ ɫɢɦɜɨɥ.
ɋɬɪɨɤɨɜɚɹ ɩɟɪɟɦɟɧɧɚɹ – ɷɬɨ ɧɟ ɱɬɨ
ɢɧɨɟ, ɤɚɤ ɦɚɫɫɢɜ ɫɢɦɜɨɥɨɜ. ɉɪɢɦɟɪ
ɨɛɴɹɜɥɟɧɢɹ:
char s[10]; // ɫɬɪɨɤɚ ɢɡ 9 ɫɢɦɜɨɥɨɜ
ɉɨɱɟɦɭ ɢɡ 9 ɫɢɦɜɨɥɨɜ, ɚ ɧɟ ɢɡ 10? ȼɫɩɨɦɧɢɦ, ɱɬɨ ɩɨɫɥɟɞɧɢɣ ɫɢɦɜɨɥ ɜɫɟɝɞɚ
‘\0’ – ɩɪɢɡɧɚɤ ɨɤɨɧɱɚɧɢɹ ɫɬɪɨɤɢ (ɧɭɥɶ-ɫɢɦɜɨɥ).
ȿɫɥɢ ɦɵ ɡɚɧɟɫɟɦ ɜ ɩɟɪɟɦɟɧɧɭɸ s ɫɬɪɨɤɭ «ɉɪɢɜɟɬ!», ɫɢɦɜɨɥɵ ɛɭɞɭɬ ɪɚɫɩɨ-
ɥɨɠɟɧɵ ɬɚɤ:
ɉ ɪ ɢ ɜ ɟ ɬ ! \0 ? ?
ɂɬɚɤ, ɫɢɧɬɚɤɫɢɫ ɨɛɴɹɜɥɟɧɢɹ ɫɬɪɨɤɨɜɨɣ ɩɟɪɟɦɟɧɧɨɣ:
char ɢɦɹ_ɫɬɪɨɤɨɜɨɣ_ɩɟɪɟɦɟɧɧɨɣ [Ɋɚɡɦɟɪ+1];
ɋɬɪɨɤɨɜɭɸ ɩɟɪɟɦɟɧɧɭɸ ɫɥɟɞɭɟɬ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɩɪɢ ɨɛɴɹɜɥɟɧɢɢ:
char hello[20] = "ȼɫɟɦ ɩɪɢɜɟɬ! ";
Ɉɩɟɪɚɰɢɢ = ɢ == ɜ ɩɪɢɦɟɧɟɧɢɢ ɤ ɫɬɪɨɤɚɦ ɬɢɩɚ char ɧɟ ɪɚɛɨɬɚɸɬ.
ɇɟɥɶɡɹ ɧɚɩɢɫɚɬɶ ɬɚɤ:
char my_string[15]; // Ɉɛɴɹɜɥɟɧɢɟ
// ɉɨɩɵɬɤɚ ɢɧɢɰɢɚɥɢɡɚɰɢɢ - ɨɲɢɛɤɚ!
my_string = "ɉɪɢɦɟɪ ɫɬɪɨɤɢ";
ȼ ɪɚɫɫɦɨɬɪɟɧɧɨɦ ɪɚɧɟɟ ɮɪɚɝɦɟɧɬɟ ɤɨɞɚ ɡɧɚɤ = ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɪɢ ɢɧɢɰɢɚ-
ɥɢɡɚɰɢɢ ɫɬɪɨɤɨɜɨɣ
ɩɟɪɟɦɟɧɧɨɣ, ɢ ɬɚɦ ɨɧ ɞɨɩɭɫɬɢɦ. ɉɪɹɦɨɟ ɠɟ ɩɪɢɫɜɨɟɧɢɟ
ɡɧɚɱɟɧɢɹ ɧɟɞɨɩɭɫɬɢɦɨ.
ȿɫɥɢ ɫɬɪɨɤɚ – ɷɬɨ ɦɚɫɫɢɜ, ɬɨ ɥɨɝɢɱɧɨ ɩɪɟɞɩɨɥɨɠɢɬɶ, ɱɬɨ ɢ ɨɛɪɚɳɚɬɶɫɹ ɤ ɟɟ
ɷɥɟɦɟɧɬɚɦ ɦɨɠɧɨ ɬɚɤ ɠɟ, ɤɚɤ ɦɵ ɨɛɪɚɳɚɟɦɫɹ ɤ ɷɥɟɦɟɧɬɚɦ ɦɚɫɫɢɜɚ, ɬ. ɟ. ɩɨ ɢɧɞɟɤɫɭ:
char my_string[15] = "ɉɪɢɦɟɪ ɫɬɪɨɤɢ";
printf( my_string[4]); // ȼɵɜɟɞɟɬ ‘ɟ’
ȿɫɥɢ ɦɵ ɯɨɬɢɦ ɢɡɦɟɧɢɬɶ ɡɧɚɱɟɧɢɟ ɫɬɪɨɤɨɜɨɣ ɩɟɪɟɦɟɧɧɨɣ ɜɨ
ɜɪɟɦɹ ɢɫɩɨɥ-
ɧɟɧɢɹ, ɧɟɨɛɯɨɞɢɦɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɭɧɤɰɢɸ strcpy:
strcpy(my_string, "ɉɪɢɦɟɪ ɫɬɪɨɤɢ");
ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ strcpy:
strcpy(ɰɟɥɟɜɚɹ ɫɬɪɨɤɚ,ɤɨɩɢɪɭɟɦɚɹ ɫɬɪɨɤɚ);
34
Ɉɩɟɪɚɰɢɸ ɫɪɚɜɧɟɧɢɹ = = ɩɪɢɦɟɧɹɬɶ ɞɥɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɫɪɚɜɧɟɧɢɹ
ɞɜɭɯ ɫɬɪɨɤ ɧɟɥɶɡɹ. Ⱦɥɹ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɣɬɟ ɮɭɧɤɰɢɸ strcmp:
if (strcmp(str1,str2))
printf("Cmpoku ɧɟ ɨɞɢɧɚɤɨɜɵɟ");
Ɉ ɪɟɡɭɥɶɬɚɬɟ ɫɪɚɜɧɟɧɢɹ ɦɨɠɧɨ ɫɭɞɢɬɶ ɩɨ ɡɧɚɤɭ ɡɧɚɱɟɧɢɹ, ɜɨɡɜɪɚɳɚɟɦɨɝɨ
strcmp:
ȿɫɥɢ Ɂɧɚɤ ɪɟɡɭɥɶɬɚɬɚ
str1 <str2 < 0
str1 >str2 > 0
str1 = str2 = 0
Ɋɚɡɦɟɪ ɫɬɪɨɤɢ ɦɨɠɧɨ ɨɩɪɟɞɟɥɢɬɶ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ strlen:
int i = strlen(my_string);
Ɏɭɧɤɰɢɹ strcat ɩɨɡɜɨɥɹɟɬ ɨɛɴɟɞɢɧɢɬɶ ɞɜɟ ɫɬɪɨɤɢ ɜ ɨɞɧɭ. ɋɢɧɬɚɤɫɢɫ
ɮɭɧɤɰɢɢ:
strcat(
ɰɟɥɟɜɚɹ ɫɬɪɨɤɚ,ɤɨɩɢɪɭɟɦɚɹ ɫɬɪɨɤɚ);
ɉɪɢɦɟɪ 2.12. Ɉɛɴɟɞɢɧɟɧɢɟ ɫɬɪɨɤ.
char s1 = "ɉɪɢɜɟɬ", s2 = "ɜɫɟɦ!";
strcat(s1,s2);
printf(s1); // ȼɵɜɨɞɢɬ "ɉɪɢɜɟɬ ɜɫɟɦ!"
Ⱦɥɹ ɫɧɹɬɢɹ ɨɝɪɚɧɢɱɟɧɢɣ ɩɨ ɞɥɢɧɟ ɫɥɟɞɭɟɬ ɨɛɴɹɜɥɹɬɶ ɫɬɪɨɤɭ ɛɟɡ ɪɚɡɦɟɪɚ
ɢɥɢ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɨɤɭ:
char s1[] = "ɋɬɪɨɤɚ ɧɟɨɝɪɚɧɢɱɟɧɧɨɣ ɞɥɢɧɵ";
char *s2 = "ɍɤɚɡɚɬɟɥɶ ɧɚ ɫɬɪɨɤɭ";
2.1.2. Ɉɩɟɪɚɬɨɪɵ ɭɩɪɚɜɥɟɧɢɹ ɋɢ
ɍɫɥɨɜɧɵɟ ɨɩɟɪɚɬɨɪɵ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɯɨɞɨɦ ɜɵɩɨɥɧɟɧɢɹ
ɩɪɨɝɪɚɦɦɵ. Ɉɧɢ ɩɨɡɜɨɥɹɸɬ ɜɜɨɞɢɬɶ
ɜɟɬɜɥɟɧɢɹ ɜ ɩɪɨɝɪɚɦɦɟ, ɤɨɝɞɚ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɡɚɞɚɧɧɨɝɨ ɭɫɥɨɜɢɹ ɜɵɩɨɥɧɟɧɢɟ ɩɪɨɝɪɚɦɦɵ ɩɪɨɢɡɜɨɞɢɬɫɹ ɩɨ ɬɨɣ ɢɥɢ
ɢɧɨɣ ɜɟɬɜɢ. ɂɧɨɝɞɚ ɢɯ ɧɚɡɵɜɚɸɬ ɨɩɟɪɚɬɨɪɚɦɢ ɩɪɢɧɹɬɢɹ ɪɟɲɟɧɢɹ.
ɍɫɥɨɜɧɵɣ ɨɩɟɪɚɬɨɪ if ɩɨɡɜɨɥɹɟɬ ɩɪɨɢɡɜɨɞɢɬɶ ɜɵɱɢɫɥɟɧɢɹ, ɟɫɥɢ ɜɵɩɨɥ-
ɧɹɟɬɫɹ ɨɩɪɟɞɟɥɟɧɧɨɟ ɭɫɥɨɜɢɟ. Ɏɨɪɦɚɬ ɨɩɟɪɚɬɨɪɚ:
if (ɭɫɥɨɜɢɟ) ɨɩɟɪɚɬɨɪ; [else ɨɩɟɪɚɬɨɪ2;]
ɗɬɭ ɡɚɩɢɫɶ ɦɨɠɧɨ ɪɚɫɲɢɮɪɨɜɵɜɚɬɶ ɬɚɤ: ɟɫɥɢ (if) ɭɫɥɨɜɢɟ ɢɫɬɢɧɧɨ, ɬɨ
ɜɵɩɨɥɧɹɟɬɫɹ ɨɩɟɪɚɬɨɪ, ɢɧɚɱɟ (else) ɜɵɩɨɥɧɹɟɬɫɹ ɨɩɟɪɚɬɨɪ2. Ʉɜɚɞɪɚɬɧɵɟ
ɫɤɨɛɤɢ ɭɤɚɡɵɜɚɸɬ ɧɚ ɧɟɨɛɹɡɚɬɟɥɶɧɵɣ ɷɥɟɦɟɧɬ ɫɢɧɬɚɤɫɢɫɚ.
ȼɧɢɦɚɧɢɟ! ɍɫɥɨɜɢɟ ɞɨɥɠɧɨ ɛɵɬɶ ɡɚɤɥɸɱɟɧɨ ɜ ɤɪɭɝɥɵɟ ɫɤɨɛɤɢ;
ȿɫɥɢ ɧɭɠɧɨ ɜɵɩɨɥɧɢɬɶ ɧɟ ɨɞɢɧ ɨɩɟɪɚɬɨɪ, ɚ ɧɟɫɤɨɥɶɤɨ, ɢɫɩɨɥɶɡɭɣɬɟ ɛɥɨɤ –
ɧɚɛɨɪ ɨɩɟɪɚɬɨɪɨɜ, ɡɚɤɥɸɱɟɧɧɵɯ ɜ ɮɢɝɭɪɧɵɟ ɫɤɨɛɤɢ.
ɉɪɢɦɟɪ 2.13. Ɉɩɟɪɚɬɨɪɵ if.
if (x==0) y++; // ȿɫɥɢ x=0, ɬɨ ɭɜɟɥɢɱɢɜɚɟɦ y
// ɧɚ ɟɞɢɧɢɰɭ
35
if (y<=0 || x>2) // ȿɫɥɢ y ɦɟɧɶɲɟ ɢɥɢ ɪɚɜɟɧ 0
// ɂɅɂ x ɛɨɥɶɲɟ 2, ɬɨ:
{
y=x++; // 1. ɉɪɢɫɜɚɢɜɚɟɦ ɭ ɡɧɚɱɟɧɢɟ x
// 2. ɍɜɟɥɢɱɢɜɚɟɦ x ɧɚ ɟɞɢɧɢɰɭ
x*=y; // 3. ɍɦɧɨɠɚɟɦ x ɧɚ y ɢ ɩɪɢɫɜɚɢɜɚɟɦ
// ɪɟɡɭɥɶɬɚɬ ɨɩɟɪɚɰɢɢ ɩɟɪɟɦɟɧɧɨɣ x
}
if (z>3 &&a*4>=3.51) // ȿɫɥɢ z ɛɨɥɶɲɟ 3 ɂ
{ // a*4 ɛɨɥɶɲɟ ɢɥɢ ɪɚɜɧɨ 3.51, ɬɨ:
y += 20*x; z = y/4; // 1. y = y + 20x
k = 21; // 2. z = y/4
} // 3. k = 21
else y = 2; // ɂɧɚɱɟ y = 2
ȼɨ ɜɬɨɪɨɦ ɢ ɬɪɟɬɶɟɦ ɨɩɟɪɚɬɨɪɚɯ if ɩɪɢ ɫɨɛɥɸɞɟɧɢɢ ɭɫɥɨɜɢɹ ɜɵɩɨɥɧɹɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɨɩɟɪɚɬɨɪɨɜ, ɩɨɷɬɨɦɭ ɦɵ ɩɪɢɦɟɧɢɥɢ ɛɥɨɤ.
Ɉɩɟɪɚɬɨɪ ɜɚɪɢɚɧɬɚ switch ɩɪɨɢɡɜɨɞɢɬ ɫɨɩɨɫɬɚɜɥɟɧɢɟ ɡɚɞɚɧɧɨɝɨ ɡɧɚɱɟɧɢɹ (ɭɩɪɚɜɥɹɸɳɟɣ ɩɟɪɟɦɟɧɧɨɣ) ɫ ɦɧɨɠɟɫɬɜɨɦ ɤɨɧɫɬɚɧɬ. Ɏɨɪɦɚɬ ɨɩɟɪɚɬɨɪɚ ɜɚ-
ɪɢɚɧɬɚ:
switch (ɭɩɪɚɜɥɹɸɳɚɹ_ɩɟɪɟɦɟɧɧɚɹ)
{
case Ɂɧɚɱɟɧɢɟ 1:
ɨɩɟɪɚɬɨɪɵ;
break;
case
Ɂɧɚɱɟɧɢɟ 2:
ɨɩɟɪɚɬɨɪɵ;
break;
case Ɂɧɚɱɟɧɢɟ n:
ɨɩɟɪɚɬɨɪɵ;
break;
[default: ɨɩɟɪɚɬɨɪɵ;
break;]
}
ɍɩɪɚɜɥɹɸɳɚɹ_ɩɟɪɟɦɟɧɧɚɹ ɦɨɠɟɬ ɛɵɬɶ ɰɟɥɨɝɨ ɬɢɩɚ ɢɥɢ ɫɢɦɜɨɥɨɦ.
Ɉɩɟɪɚɬɨɪɵ break ɩɪɢɦɟɧɹɸɬɫɹ ɞɥɹ ɜɵɯɨɞɚ ɢɡ ɨɩɟɪɚɬɨɪɚ switch. ȿɫɥɢ
ɩɪɨɜɟɪɹɟɦɨɟ ɡɧɚɱɟɧɢɟ ɧɟ ɫɨɜɩɚɞɚɟɬ ɧɢ ɫ ɨɞɧɨɣ ɢɡ ɤɨɧɫɬɚɧɬ, ɜɵɩɨɥɧɹɟɬɫɹ ɜɚɪɢɚɧɬ default (ɭɦɨɥɱɚɧɢɟ).
ɉɪɢɦɟɪ 2.14. Ɉɩɟɪɚɬɨɪ switch.
int q;
switch (q) {
case 0: x = 2.05*z – 3.6;
y = 5*x;
break;
case 1: x = 3; y = 2; z = 1; break;
case 2: x = 2*y – 6,7*z +1;
36
y = 5*y – x;
z = x;
break;
default: x++; y/= z; z = x+1; break;
}
ȼ ɞɚɧɧɨɦ ɩɪɢɦɟɪɟ ɜ ɤɚɱɟɫɬɜɟ ɭɩɪɚɜɥɹɸɳɟɣ ɩɟɪɟɦɟɧɧɨɣ ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɟɪɟ-
ɦɟɧɧɚɹ q ɰɟɥɨɝɨ ɬɢɩɚ. ȿɫɥɢ q = 0, ɬɨ ɜɵɩɨɥɧɹɟɬɫɹ ɪɚɫɱɟɬ ɩɨ ɮɨɪɦɭɥɚɦ: x =
= 2,05*z – 3,6 ɢ y = 5*x; ɟɫɥɢ q = 1, ɬɨ ɩɟɪɟɦɟɧɧɵɦ x, y ɢ z ɩɪɢɫɜɚɢɜɚɸɬɫɹ ɡɧɚɱɟɧɢɹ: x = 3, y = 2 ɢ z = 1; ɟɫɥɢ q = 2, ɬɨ ɜɵɩɨɥɧɹɟɬɫɹ
ɪɚɫɱɟɬ ɩɨ ɮɨɪɦɭɥɚɦ: x = 2*y – 6,7*z + 1, y = 5*y – x ɢ z = x.
ȿɫɥɢ ɠɟ q ɧɟ ɪɚɜɧɨ ɧɢ
0, ɧɢ 1, ɧɢ 2, ɜɵɩɨɥɧɹɟɬɫɹ ɪɚɫɱɟɬ ɩɨ ɮɨɪɦɭɥɚɦ: x++,
y/= z ɢ z = x + 1.
ȿɫɥɢ ɠɟ ɚɥɶɬɟɪɧɚɬɢɜ ɞɥɹ ɜɵɛɨɪɚ ɧɟɫɤɨɥɶɤɨ, ɢɯ ɩɟɪɟɱɢɫɥɹɸɬ ɩɨɞɪɹɞ, ɤɚɤ
ɩɨɤɚɡɚɧɨ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 2.15. Ɉɩɟɪɚɬɨɪ switch ɫ ɧɟɫɤɨɥɶɤɢɦɢ ɚɥɶɬɟɪɧɚɬɢɜɚɦɢ.
switch (a)
{
case 0: x = 2*a; // ȿɫɥɢ ɚ = 0, ɬɨ:
y++; // x = 2a, y = y +1
break;
case -2: // ȿɫɥɢ a = -2, ɬɨ:
x = 2; y = 3; // x = 2, y = 3
break;
case 1: // ȿɫɥɢ a = 1,
case 2: // ɢɥɢ a = 2,
case 7: // ɢɥɢ a =7,
case 8: // ɢɥɢ a = 8, ɬɨ:
y = 2*a –1; // y = 2a - 1
break;
}
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɩɨɫɥɟɞɧɢɟ ɱɟɬɵɪɟ
ɫɬɪɨɤɢ ɜ ɩɪɢɦɟɪɟ 2.15. Ɉɧɢ ɭɤɚ-
ɡɵɜɚɸɬ ɧɚ ɬɨ, ɱɬɨ ɟɫɥɢ ɩɟɪɟɦɟɧɧɚɹ a ɜɯɨɞɢɬ ɜɨ ɦɧɨɠɟɫɬɜɨ {1;2;7;8}, ɬɨ
ɜɵɩɨɥɧɹɟɬɫɹ ɨɩɟɪɚɬɨɪ y = 2*a -1.
Ɉɩɟɪɚɬɨɪ ɛɟɡɭɫɥɨɜɧɨɝɨ ɩɟɪɟɯɨɞɚ goto ɨɫɭɳɟɫɬɜɥɹɟɬ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɵɣ
ɩɟɪɟɯɨɞ ɤ ɭɤɚɡɚɧɧɨɣ ɫɬɪɨɤɟ ɩɪɨɝɪɚɦɦɵ (ɛɟɡ ɭɫɥɨɜɢɣ). Ɏɨɪɦɚɬ ɨɩɟɪɚɬɨɪɚ:
goto ɢɦɹ_ɦɟɬɤɢ;
Ʉɚɤ ɬɨɥɶɤɨ ɨɩɟɪɚɬɨɪ goto ɜɫɬɪɟɱɚɟɬɫɹ ɜ ɩɪɨɝɪɚɦɦɟ, ɫɪɚɡɭ (ɛɟɡ ɜɫɹɤɢɯ
ɭɫɥɨɜɢɣ) ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɩɟɪɟɯɨɞ ɧɚ
ɫɬɪɨɤɭ, ɤɨɬɨɪɚɹ ɧɚɱɢɧɚɟɬɫɹ ɫ ɦɟɬɤɢ, ɢɦɟɸɳɟɣ ɢɦɹ ɢɦɹ_ɦɟɬɤɢ. Ɇɟɬɤɚ – ɷɬɨ ɧɚɛɨɪ ɫɢɦɜɨɥɨɜ (ɰɢɮɪ ɢ/ɢɥɢ ɛɭɤɜ). Ɇɟɬɤɚɦ ɠɟɥɚɬɟɥɶɧɨ ɞɚɜɚɬɶ ɨɫɦɵɫɥɟɧɧɵɟ ɢɦɟɧɚ.
Ɋɚɫɫɦɨɬɪɢɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɨɩɟɪɚɬɨɪɚ goto ɧɚ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 2.16. ɂɫɩɨɥɶɡɨɜɚɧɢɟ goto.
if (size >= 10) goto label1;
goto label2;
37
label1: cost = cost*1.05; flag = 2;
label2: bill = cost*flag;
ɉɪɢɜɟɞɟɧɧɵɣ ɮɪɚɝɦɟɧɬ ɩɪɨɝɪɚɦɦɵ ɪɚɛɨɬɚɟɬ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ. ȿɫɥɢ
ɡɧɚɱɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ size ɛɨɥɶɲɟ ɢɥɢ ɪɚɜɧɨ 10, ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɩɟɪɟɯɨɞ
ɧɚ ɫɬɪɨɤɭ, ɩɨɦɟɱɟɧɧɭɸ ɦɟɬɤɨɣ label1 ɢ ɜɵɩɨɥɧɹɸɬɫɹ ɨɩɟɪɚɬɨɪɵ cost =
= cost*1.05 ɢ flag = 2. ȿɫɥɢ ɭɫɥɨɜɢɟ ɧɟ ɜɵɩɨɥɧɹɟɬɫɹ, ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ
ɩɟɪɟɯɨɞ ɧɚ ɫɬɪɨɤɭ, ɩɨɦɟɱɟɧɧɭɸ ɦɟɬɤɨɣ label2 ɢ ɜɵɩɨɥɧɹɟɬɫɹ ɨɩɟɪɚɬɨɪ
bill = cost*flag.
Ɉɩɟɪɚɬɨɪ goto – ɷɬɨ ɚɧɚɯɪɨɧɢɡɦ, ɩɪɢɲɟɞɲɢɣ ɢɡ ɛɨɥɟɟ ɪɚɧɧɢɯ ɹɡɵɤɨɜ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ
, ɬɚɤɢɯ, ɤɚɤ Fortran ɢ Basic. ȿɫɥɢ ɟɫɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɝɨ, ɬɨ ɢɫɤɥɸɱɚɣɬɟ ɷɬɨɬ ɨɩɟɪɚɬɨɪ ɢɡ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦ. Ɍɚɤ, ɧɚɩɪɢɦɟɪ, ɬɟɤɫɬ ɩɪɢɦɟɪɚ 2.16 ɦɨɠɧɨ ɡɚɩɢɫɚɬɶ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
if (size >= 10)
{ cost = cost*1.05; flag = 2;
} bill = cost*flag;
ȼ ɩɨɫɥɟɞɧɟɦ ɫɥɭɱɚɟ ɩɪɨɝɪɚɦɦɚ ɫɬɚɥɚ ɛɨɥɟɟ ɩɨɧɹɬɧɨɣ ɢ ɧɟ ɫɨɞɟɪɠɢɬ «ɩɨɞ-
ɜɨɞɧɵɯ ɤɚɦɧɟɣ».
Ʉɨɧɟɱɧɨ, ɢɡ ɜɫɟɯ ɩɪɚɜɢɥ ɜɫɟɝɞɚ ɫɭɳɟɫɬɜɭɸɬ ɢɫɤɥɸɱɟɧɢɹ. Ɍɚɤ, ɧɚɩɪɢɦɟɪ,
ɨɩɟɪɚɬɨɪ
goto ɭɞɨɛɧɨ ɩɪɢɦɟɧɹɬɶ ɞɥɹ ɜɵɯɨɞɚ ɢɡ ɫɥɨɠɧɨɝɨ ɜɥɨɠɟɧɧɨɝɨ ɰɢɤɥɚ
ɩɪɢ ɨɛɧɚɪɭɠɟɧɢɢ ɨɲɢɛɨɤ.
ɐɢɤɥ – ɷɬɨ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɩɨɜɬɨɪɹɸɳɢɯɫɹ ɞɟɣɫɬɜɢɣ (ɨɩɟɪɚɬɨɪɨɜ).
Ʉɨɥɢɱɟɫɬɜɨ ɩɨɜɬɨɪɟɧɢɣ ɡɚɞɚɟɬɫɹ ɥɢɛɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ, ɥɢɛɨ ɨɩɪɟɞɟɥɹɟɬɫɹ
ɭɫɥɨɜɢɟɦ.
ȼ ɋɢ ɢɦɟɟɬɫɹ ɬɪɢ ɪɚɡɧɨɜɢɞɧɨɫɬɢ ɰɢɤɥɨɜ:
ɰɢɤɥ ɫ ɩɚɪɚɦɟɬɪɨɦ for;
ɰɢɤɥ ɫ ɩɪɟɞɭɫɥɨɜɢɟɦ while;
ɰɢɤɥ ɫ ɩɨɫɬɭɫɥɨɜɢɟɦ do while.
Ʉɚɠɞɵɣ ɜɚɪɢɚɧɬ ɰɢɤɥɚ ɨɛɟɫɩɟɱɢɜɚɟɬ ɨɩɪɟɞɟɥɟɧɧɵɟ ɭɫɥɨɜɢɹ ɜɵɩɨɥɧɟɧɢɹ
ɩɪɨɝɪɚɦɦɵ, ɤɨɬɨɪɵɟ ɦɵ ɪɚɫɫɦɨɬɪɢɦ ɧɢɠɟ.
Ɉɩɟɪɚɬɨɪ ɰɢɤɥɚ for ɩɨɡɜɨɥɹɟɬ ɡɚɞɚɬɶ ɩɨɜɬɨɪɟɧɢɟ ɝɪɭɩɩɵ ɨɩɟɪɚɬɨɪɨɜ ɡɚ-
ɞɚɧɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɪɚɡ. Ɍɚɤɨɣ ɰɢɤɥ ɱɚɫɬɨ ɧɚɡɵɜɚɸɬ ɰɢɤɥɨɦ ɫ ɩɚɪɚɦɟɬɪɨɦ.
ɋɢɧɬɚɤɫɢɫ ɨɩɟɪɚɬɨɪɚ for ɫɥɟɞɭɸɳɢɣ:
for (ɢɧɢɰɢɚɥɢɡɚɰɢɹ; ɭɫɥɨɜɢɟ; ɤɨɪɪɟɤɰɢɹ) ɨɩɟɪɚɬɨɪ;
Ɂɞɟɫɶ:
ɢɧɢɰɢɚɥɢɡɚɰɢɹ – ɭɫɬɚɧɨɜɤɚ ɧɚɱɚɥɶɧɨɝɨ ɡɧɚɱɟɧɢɹ ɩɟɪɟɦɟɧɧɨɣ-ɫɱɟɬɱɢɤɚ;
ɭɫɥɨɜɢɟ – ɜɵɪɚɠɟɧɢɟ, ɨɩɪɟɞɟɥɹɸɳɟɟ ɭɫɥɨɜɢɟ, ɩɪɢ ɤɨɬɨɪɨɦ ɰɢɤɥ ɛɭɞɟɬ
ɜɵɩɨɥɧɹɬɶɫɹ;
ɤɨɪɪɟɤɰɢɹ –
ɢɡɦɟɧɟɧɢɟ ɡɧɚɱɟɧɢɹ ɩɟɪɟɦɟɧɧɨɣ-ɫɱɟɬɱɢɤɚ.
Ⱥɥɝɨɪɢɬɦ ɪɚɛɨɬɵ ɰɢɤɥɚ for:
1. ȼɵɱɢɫɥɹɟɬɫɹ ɜɵɪɚɠɟɧɢɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ, ɜ ɪɟɡɭɥɶɬɚɬɟ ɱɟɝɨ ɩɟɪɟɦɟɧ-
ɧɨɣ-ɫɱɟɬɱɢɤɭ ɩɪɢɫɜɚɢɜɚɟɬɫɹ ɧɚɱɚɥɶɧɨɟ ɡɧɚɱɟɧɢɟ.
38
2. ȼɵɱɢɫɥɹɟɬɫɹ ɭɫɥɨɜɧɨɟ ɜɵɪɚɠɟɧɢɟ. ȿɫɥɢ ɭɫɥɨɜɢɟ ɢɫɬɢɧɧɨ, ɬɨ ɜɵɩɨɥ-
ɧɹɟɬɫɹ ɨɩɟɪɚɬɨɪ. ȿɫɥɢ ɭɫɥɨɜɢɟ ɥɨɠɧɨ, ɰɢɤɥ ɡɚɜɟɪɲɚɟɬɫɹ.
3. ȼɵɱɢɫɥɹɟɬɫɹ ɜɵɪɚɠɟɧɢɟ ɤɨɪɪɟɤɰɢɢ, ɜ ɪɟɡɭɥɶɬɚɬɟ ɱɟɝɨ ɩɟɪɟɦɟɧɧɨɣ-
ɫɱɟɬɱɢɤɭ ɩɪɢɫɜɚɢɜɚɟɬɫɹ ɧɨɜɨɟ ɡɧɚɱɟɧɢɟ.
4. Ɉɫɭɳɟɫɬɜɥɹɟɬɫɹ ɩɟɪɟɯɨɞ ɤ ɩ. 2.
Ɋɚɫɫɦɨɬɪɢɦ ɩɪɨɫɬɨɣ ɩɪɢɦɟɪ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɨɩɟɪɚɬɨɪɚ for.
ɉɪɢɦɟɪ 2.17. ɉɪɨɫɬɨɣ ɨɩɟɪɚɬɨɪ for.
int n;
for (n = 0;n<10;n++) printf("%d \n",n);
ȼ ɪɟɡɭɥɶɬɚɬɟ ɜɵɩɨɥɧɟɧɢɹ ɩɪɢɜɟɞɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ ɧɚ ɷɤɪɚɧ
ɛɭɞɭɬ ɜɵɜɟɞɟ-
ɧɵ ɰɢɮɪɵ ɨɬ 0 ɞɨ 9.
ȿɫɥɢ ɧɭɠɧɨ ɜɵɩɨɥɧɢɬɶ ɧɟ ɨɞɢɧ ɨɩɟɪɚɬɨɪ, ɚ ɧɟɫɤɨɥɶɤɨ, ɜɤɥɸɱɚɣɬɟ ɢɯ ɜ
ɛɥɨɤ, ɤɚɤ ɩɨɤɚɡɚɧɨ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 2.18. Ɉɩɟɪɚɬɨɪ for ɫ ɛɥɨɤɨɦ.
int j = 0;
for (j = 0;j<5; j++)
{
float x = 20*sin(j);
float y = 3*x;
printf("%d x = %f y = %f \n", j, x, y); }
ȼ ɞɚɧɧɨɦ ɩɪɢɦɟɪɟ 5 ɪɚɡ ɪɚɫɫɱɢɬɵɜɚɸɬɫɹ ɢ ɜɵɜɨɞɹɬɫɹ ɧɚ ɷɤɪɚɧ ɡɧɚɱɟɧɢɹ
ɮɭɧɤɰɢɣ x = 20*sin(j) ɢ y = 3*x. ɋɢɦɜɨɥɵ %d ɢ %f ɜ ɮɭɧɤɰɢɢ printf
ɭɤɚɡɵɜɚɸɬ ɧɚ
ɩɨɡɢɰɢɢ ɜɵɜɨɞɚ ɰɟɥɨɝɨ ɢ ɜɟɳɟɫɬɜɟɧɧɨɝɨ ɡɧɚɱɟɧɢɣ, ɫɨɨɬɜɟɬɫɬɜɟɧ-
ɧɨ.
Ʉɨɪɪɟɤɰɢɹ ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ ɞɨɥɠɧɚ ɛɵɬɶ ɰɟɥɨɱɢɫɥɟɧɧɨɣ. ȼ ɫɥɟɞɭɸɳɟɦ
ɩɪɢɦɟɪɟ ɜ ɪɚɡɞɟɥɟ ɤɨɪɪɟɤɰɢɢ ɡɧɚɱɟɧɢɟ ɭɩɪɚɜɥɹɸɳɟɣ ɩɟɪɟɦɟɧɧɨɣ ɜɵɱɢɫɥɹɟɬɫɹ
ɩɨ ɮɨɪɦɭɥɟ.
ɉɪɢɦɟɪ 2.19. Ɉɩɟɪɚɬɨɪ for ɫɨ ɫɥɨɠɧɨɣ ɤɨɪɪɟɤɰɢɟɣ.
int x; float y;
for (x = 1;y<=75;y = 5*x++ + 10)
printf("x = %d y = %f \n", x, y);
Ɉɛɪɚɬɢɬɟ ɨɫɨɛɨɟ ɜɧɢɦɚɧɢɟ ɧɚ ɩɪɢɦɟɪ 2.19. ȿɫɥɢ ɜ ɞɜɭɯ ɩɪɟɞɵɞɭɳɢɯ ɩɪɢɦɟɪɚɯ ɞɥɹ ɩɪɨɜɟɪɤɢ ɭɫɥɨɜɢɹ ɢ ɤɨɪɪɟɤɰɢɢ ɢɫɩɨɥɶɡɨɜɚɥɚɫɶ ɩɟɪɟɦɟɧɧɚɹ – «ɫɱɟɬ
-
ɱɢɤ ɰɢɤɥɚ», ɬɨ ɜ ɩɪɢɦɟɪɟ 2.19 ɞɥɹ ɩɪɨɜɟɪɤɢ ɭɫɥɨɜɢɹ ɢ ɞɥɹ ɤɨɪɪɟɤɰɢɢ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɚɹ ɩɟɪɟɦɟɧɧɚɹ y.
Ⱥ ɜɨɬ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ ɨɬɫɭɬɫɬɜɭɸɬ ɜɵɪɚɠɟɧɢɹ ɜ ɞɜɭɯ ɪɚɡɞɟɥɚɯ –
ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɢ ɤɨɪɪɟɤɰɢɢ. ɐɢɤɥ ɛɭɞɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ȼɵ ɧɟ
ɜɜɟɞɟɬɟ ɱɢɫɥɨ, ɛɨɥɶɲɟɟ ɢ ɪɚɜɧɨɟ 5.
ɉɪɢɦɟɪ 2.20. Ɉɩɟɪɚɬɨɪ for ɛɟɡ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɢ ɤɨɪɪɟɤɰɢɢ.
#include <stdio.h>
int main() {
int num = 0;
printf("%s \n","Enter number");
for (; num<=5;)
39
// Enter number – ȼɜɟɞɢɬɟ ɱɢɫɥɨ
scanf("%d", num);
printf("It is good number!");
return 0;
}
ɒɚɝ ɤɨɪɪɟɤɰɢɢ ɦɨɠɟɬ ɛɵɬɶ ɢ ɞɪɨɛɧɵɦ.
ɉɪɢɦɟɪ 2.21. ɐɢɤɥ for ɫ ɞɪɨɛɧɨɣ ɤɨɪɪɟɤɢɰɟɣ.
for (float i=0;i<2;i+=0.2)
ȼ ɩɪɢɦɟɪɟ 2.21 ɩɪɢɪɚɳɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ-ɫɱɟɬɱɢɤɚ ɰɢɤɥɚ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɫ
ɲɚɝɨɦ 0,2.
ɉɪɢɦɟɧɟɧɢɟ ɜ ɪɚɡɞɟɥɚɯ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɢ ɤɨɪɪɟɤɰɢɢ ɨɩɟɪɚɰɢɢ «ɡɚɩɹɬɚɹ»
ɩɨɡɜɨɥɹɟɬ ɫɭɳɟɫɬɜɟɧɧɨ ɭɜɟɥɢɱɢɬɶ ɝɢɛɤɨɫɬɶ ɰɢɤɥɚ for.
Ɋɚɫɫɦɨɬɪɢɦ ɷɬɨ ɧɚ ɩɪɢɦɟɪɟ ɩɪɨɝɪɚɦɦɵ, ɤɨɬɨɪɚɹ ɜɵɱɢɫɥɹɟɬ ɫɬɨɢɦɨɫɬɶ ɨɬɩɪɚɜɤɢ ɩɨɫɵɥɤɢ
ɧɚ ɩɨɱɬɟ. Ɍɚɪɢɮ ɨɰɟɧɤɢ ɬɚɤɨɣ: 120 ɪɭɛ. ɡɚ ɩɟɪɜɵɣ ɤɢɥɨɝɪɚɦɦ ɢ
ɩɨ 35,6 ɪɭɛ. ɡɚ ɤɚɠɞɵɟ ɩɨɫɥɟɞɭɸɳɢɟ 200 ɝɪɚɦɦ.
ɉɪɢɦɟɪ 2.22. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɨɩɟɪɚɬɨɪɚ for ɞɥɹ ɜɵɜɨɞɚ ɬɚɛɥɢɰɵ.
#include <stdio.h>
#include <locale.h>
#define FIRST 120
#define NEXT 35.6
int main() {
float weight;
float cost;
char* s = "ȼɟɫ, ɤɝ ɋɬɨɢɦɨɫɬɶ, ɪɭɛ.";
setlocale(LC_ALL, "RUS");
printf("%s \n",s);
for(weight=1,cost=FIRST;weight<=10;weight++,
cost+=NEXT)
printf("%2d %.2f \n", weight, cost);
return 0;
}
Ɂɞɟɫɶ ɦɵ ɢɫɩɨɥɶɡɨɜɚɥɢ ɡɚɩɹɬɭɸ ɜ ɪɚɡɞɟɥɚɯ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɢ ɤɨɪɪɟɤɰɢɢ.
ɗɬɨ ɩɨɡɜɨɥɢɥɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɫɪɚɡɭ ɞɜɟ ɩɟɪɟɦɟɧɧɵɟ: weight (ɜɟɫ) ɢ cost
(ɰɟɧɚ). Ʉɪɨɦɟ ɬɨɝɨ, ɜ ɪɚɡɞɟɥɟ ɤɨɪɪɟɤɰɢɢ ɦɵ ɢɡɦɟɧɹɟɦ ɡɧɚɱɟɧɢɹ ɷɬɢɯ ɠɟ ɩɟɪɟɦɟɧɧɵɯ: ɩɟɪɟɦɟɧɧɚɹ weight ɧɚ ɤɚɠɞɨɦ ɲɚɝɟ ɰɢɤɥɚ ɭɜɟɥɢɱɢɜɚɟɬɫɹ ɧɚ ɟɞɢɧɢɰɭ, ɚ ɩɟɪɟɦɟɧɧɚɹ cost ɭɜɟɥɢɱɢɜɚɟɬɫɹ ɧɚ 35.6.
ɍɫɥɨɜɢɟ ɜɵɩɨɥɧɟɧɢɹ ɰɢɤɥɚ ɨɩɪɟɞɟɥɹɟɬɫɹ ɫ ɩɨɦɨɳɶɸ ɩɟɪɟɦɟɧɧɨɣ weight.
Ɏɭɧɤɰɢɹ setlocale ɩɨɡɜɨɥɹɟɬ ɤɨɪɪɟɤɬɧɨ ɨɬɨɛɪɚɠɚɬɶ ɫɢɦɜɨɥɵ ɤɢɪɢɥɥɢɰɵ ɧɚ ɷɤɪɚɧɟ. ȿɟ ɩɪɨɬɨɬɢɩ ɧɚɯɨɞɢɬɫɹ ɜ ɛɢɛɥɢɨɬɟɤɟ
locale.h (ɫɦ. ɉɪɢɥɨ-
ɠɟɧɢɟ Ⱥ).
Ɉɩɟɪɚɬɨɪ while ɨɪɝɚɧɢɡɭɟɬ ɰɢɤɥ ɫ ɩɪɟɞɭɫɥɨɜɢɟɦ. Ɍɟɪɦɢɧ ɩɪɟɞɭɫɥɨɜɢɟ
ɨɡɧɚɱɚɟɬ, ɱɬɨ ɭɫɥɨɜɢɟ ɜɵɩɨɥɧɟɧɢɹ ɰɢɤɥɚ ɜɵɱɢɫɥɹɟɬɫɹ ɤɚɠɞɵɣ ɪɚɡ ɜ ɧɚɱɚɥɟ
ɰɢɤɥɚ. Ɉɩɟɪɚɬɨɪ ɢɦɟɟɬ ɫɥɟɞɭɸɳɢɣ ɮɨɪɦɚɬ: while (ɜɵɪɚɠɟɧɢɟ) ɨɩɟɪɚ-
ɬɨɪ;
40
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]