Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

Программирование на C / C++ / Андрей Богатырев. C для идиотов

.TXT
Скачиваний:
72
Добавлен:
02.05.2014
Размер:
123.35 Кб
Скачать
Ђ­¤аҐ© Ѓ®Ј влॢ.

ђгЄ®ў®¤бвў® Ї®«­®Ј® Ё¤Ё®в  Ї® Їа®Ја ¬¬Ёа®ў ­Ёо (­  п§лЄҐ ‘Ё)

С Copyright Ђ­¤аҐ© Ѓ®Ј влॢ
Email: abs@opentech.olvit.ru
---------------------------------------------------------------------------

Џ…ђ…Њ…ЌЌ›…

ЏҐаҐ¬Ґ­­ п - нв® в Є®© "пйЁзҐЄ" б Ё¬Ґ­Ґ¬,
ў Є®в®а®¬ ¬®¦Ґв еа ­Ёвмбп ­ҐЄ®Ґ ‡ЌЂ—…Ќ€….
€¬п г ЇҐаҐ¬Ґ­­®© Ї®бв®п­­® Ё ­ҐЁ§¬Ґ­­®,
§­ зҐ­ЁҐ ¦Ґ ¬®¦Ґв ¬Ґ­пвмбп.

Ќ ЇаЁ¬Ґа, Їгбвм г ­ б Ґбвм ЇҐаҐ¬Ґ­­ п б Ё¬Ґ­Ґ¬ "x".

-----
/ x /
---------------
| ’ҐЄг饥 |
| §­ зҐ­ЁҐ, |
| ­ ЇаЁ¬Ґа 12 |
---------------

ЏҐаҐ¬Ґ­­го ¬®¦­® Ё§¬Ґ­пвм ЇаЁ Ї®¬®йЁ ®ЇҐа жЁЁ Џђ€‘‚Ђ€‚ЂЌ€џ.
‚ п§лЄҐ ‘Ё ®­  ®Ў®§­ з Ґвбп §­ Є®¬ а ўҐ­бвў .

x = 12 ;

ќв® зЁв Ґвбп ­Ґ Є Є "ЁЄб а ў­® 12",
  Є Є "ЇаЁбў®Ёвм ЇҐаҐ¬Ґ­­®© ЁЄб §­ зҐ­ЁҐ 12",
в® Ґбвм "Џ®«®¦Ёвм ў пйЁЄ б ­ ¤ЇЁбмо €Љ‘ зЁб«® 12".

’ Є п бва®Є  пў«пҐвбп Їа®б⥩訬 ЋЏ…ђЂ’ЋђЋЊ,
в® Ґбвм „…‰‘’‚€…Њ. ‚ Є®­жҐ ®ЇҐа в®а®ў бв ўЁвбп в®зЄ  б § Їпв®©.

ђ бᬮваЁ¬ ®ЇҐа в®а

x = x + 3;

ќв® ­Ґ га ў­Ґ­ЁҐ. …б«Ё а бб¬ ваЁў вм нвг бва®Єг Є Є ¬ вҐ¬ вЁзҐбЄ®Ґ
га ў­Ґ­ЁҐ, ®­® ­Ґ Ё¬ҐҐв аҐиҐ­Ё©. Ќ  б ¬®¬ ¤Ґ«Ґ вгв ­ ЇЁб ­®:

1) "ў§пвм §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© €Љ‘"
2) "ЇаЁЎ ўЁвм Є ­Ґ¬г 3"
3) "Ї®«®¦Ёвм ­®ў®Ґ §­ зҐ­ЁҐ ў ЇҐаҐ¬Ґ­­го €Љ‘",
бвҐаҐў ў ­Ґ© ЇаҐ¦­ҐҐ §­ зҐ­ЁҐ.

“ ®ЇаҐ в®а  ЇаЁбў Ёў ­Ёп Ґбвм ¤ўҐ з бвЁ: ‹…‚Ђџ Ё ЏђЂ‚Ђџ.

‹…‚Ђџ_—Ђ‘’њ = ЏђЂ‚Ђџ_—Ђ‘’њ ;

‚ «Ґў®© з бвЁ ®Ўлз­® бв®Ёв Їа®бв® Ё¬п ЇҐаҐ¬Ґ­­®© ‚ ЉЋ’Ћђ“ћ
§ ЇЁблў Ґвбп ўлзЁб«Ґ­­л© бЇа ў  १г«мв в.

…б«Ё Ё¬п ЇҐаҐ¬Ґ­­®© ўбваҐз Ґвбп ў ЏђЂ‚Ћ‰ з бвЁ, в® нв®
®§­ з Ґв "Ї®¤бв ўЁвм бо¤  ⥪г饥 §­ зҐ­ЁҐ нв®© ЇҐаҐ¬Ґ­­®©".

ЏаЁ н⮬ ⥪г饥 §­ зҐ­ЁҐ б ¬®© ЇҐаҐ¬Ґ­­®© Ќ… Ё§¬Ґ­пҐвбп,
ЎҐаҐвбп ҐЈ® Є®ЇЁп. ’® Ґбвм, "ўл­г⮥ Ё§ пйЁЄ  §­ зҐ­ЁҐ"
­Ґ ®бв ў«пҐв пйЁЄ Їгбвл¬! ‚л­Ё¬ Ґвбп Є®ЇЁп, ¤агЈ п Є®ЇЁп ®бв Ґвбп ў пйЁЄҐ.

€в Є:

x = x + 3 ;

Џгбвм ᥩз б §­ зҐ­ЁҐ x Ґбвм 12

‘­ з «  ўлзЁб«пҐвбп ЏђЂ‚Ђџ з бвм ®ЇҐа в®а  ЇаЁбў Ёў ­Ёп.

x + 3

-----
/ x /
---------------
| 12 | |
--------|------
|
|
| ‚‡џ’њ Є®ЇЁо §­ зҐ­Ёп (в® Ґбвм зЁб«® 12) Ё§ пйЁЄ  б Ё¬Ґ­Ґ¬ "€Љ‘"
|
V
‚¬Ґбв® x
Ї®¤бв ў«пҐ¬
зЁб«®
12 + 3 ----> ‘Љ‹Ђ„›‚Ђ…Њ.

‘«®¦Ґ­ЁҐ ¤ Ґв 15.
‚ нв®в ¬®¬Ґ­в x ўбҐ ҐйҐ а ў­® 12
(ў пйЁЄҐ «Ґ¦Ёв зЁб«® 12)

’ҐЇҐам ўлзЁб«пҐвбп б ¬® ЇаЁбў Ёў ­ЁҐ:

x = 15 ;

|
|
| ЏЋ‹Ћ†€’њ १г«мв в ў пйЁЄ б Ё¬Ґ­Ґ¬ "€Љ‘"
| (ЁбвॡЁў ў ­Ґ¬ ЇаҐ¦­ҐҐ §­ зҐ­ЁҐ, Ґб«Ё Ўл«®)
-----|
/ x / |
--------|------
| 12 V |
---------------

‘в «®:
-----
/ x /
---------------
| 15 |
---------------

‚ ЇҐаҐ¬Ґ­­®© б ⥬ ¦Ґ Ё¬Ґ­Ґ¬ ⥯Ґам ­ е®¤Ёвбп ­®ў®Ґ §­ зҐ­ЁҐ,
®­  Ё§¬Ґ­Ё« бм. Џ®в®¬г Ё "ЇҐаҐ¬Ґ­­ п".

‚ ­ҐЄ®в®але п§лЄ е Їа®Ја ¬¬Ёа®ў ­Ёп, ­ ЇаЁ¬Ґа ў Pascal Ё«Ё Modula,
®ЇҐа жЁп ЇаЁбў Ёў ­Ёп ®Ў®§­ з Ґвбп бЁ¬ў®«®¬ :=   ­Ґ =
ќв® 㬥­ми Ґв Їгв ­Ёжг, ­® Є б¬лб«г = ¬®¦­® ЇаЁўлЄ­гвм ¤®ў®«м­® Ўлбва®.
ЌҐ ®Ј®аз ©вҐбм.

‚ Їа ў®© з бвЁ §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© ¬®¦Ґв ЁбЇ®«м§®ў вмбп ­ҐбЄ®«мЄ® а §:

z = x * x + 2 * x;

’гв Ґбвм ¤ўҐ ЇҐаҐ¬Ґ­­лҐ:

z - ¤«п १г«мв в .
x - 㦥 Ё¬Ґой п Є Є®Ґ-в® §­ зҐ­ЁҐ.

x * x ®§­ з Ґв "г¬­®¦Ёвм ЁЄб ­  ЁЄб" (ЇаЁ н⮬ б ¬® §­ зҐ­ЁҐ,
«Ґ¦ йҐҐ ў пйЁЄҐ ЁЄб ­Ґ Ё§¬Ґ­пҐвбп!)

x * 2 ®§­ з Ґв "ў§пвм ¤ў  §­ зҐ­Ёп ЁЄб"

+ ®§­ з Ґв б«®¦Ґ­ЁҐ.

ЏҐаҐ¬Ґ­­лҐ ­ ¤® ЋЃљџ‚‹џ’њ.
ќв® ­Ґ®Ўе®¤Ё¬® Ї®в®¬г, зв® Ё­ зҐ, Ґб«Ё Ўл ЇҐаҐ¬Ґ­­лҐ ўў®¤Ё«Ёбм Їа®бв®
ЁбЇ®«м§®ў ­ЁҐ¬ Ё¬Ґ­Ё ЇҐаҐ¬Ґ­­®©, Ё ¬л ў¤агЈ ¤®ЇгбвЁ«Ё Ўл ЋЏ…—Ђ’Љ“, ­ ЇаЁ¬Ґа:

Ё¤­ҐЄб = 1;

ў¬Ґбв®

Ё­¤ҐЄб = 1;

в® г ­ б Ї®пўЁ« бм Ўл "«Ёи­пп" ЇҐаҐ¬Ґ­­ п "Ё¤­ҐЄб",   ®¦Ё¤ Ґ¬®Ґ ¤Ґ©бвўЁҐ ­Ґ
Їа®Ё§®и«® Ўл. ’ Єго ®иЁЎЄг ­ ©вЁ зҐаҐ§ўлз ©­® в殮«®. …б«Ё ¦Ґ ЇҐаҐ¬Ґ­­лҐ
­ ¤® ®Ўкпў«пвм, в® ­Ґ®Ўкпў«Ґ­­лҐ ЇҐаҐ¬Ґ­­лҐ Ўг¤гв ўлпў«Ґ­л ҐйҐ ­  бв ¤ЁЁ
Є®¬ЇЁ«пжЁЁ Їа®Ја ¬¬л.

ЏҐаҐ¬Ґ­­лҐ, Є®в®алҐ Ўг¤гв еа ­Ёвм жҐ«лҐ зЁб«  ( ..., -2, -1, 0, 1, 2, 3, ...),
®Ўкпў«пов в Є:

int ЇҐаҐ¬Ґ­­ п1;
int ЇҐаҐ¬Ґ­­ п2;

€«Ё ба §г ­ҐбЄ®«мЄ® ў ®¤­®© бва®ЄҐ:

int ЇҐаҐ¬Ґ­­ п1, ЇҐаҐ¬Ґ­­ п2;

int ®§­ з Ґв б®Єа йҐ­ЁҐ ®в б«®ў  integer - "楫л©".

ЏђЋѓђЂЊЊЂ

Џа®Ја ¬¬  б®бв®Ёв Ё§ ЋЏ…ђЂ’ЋђЋ‚, в® Ґбвм ¤Ґ©бвўЁ©.
ЋЇҐа в®ал ўлЇ®«­повбп Ї®б«Ґ¤®ў вҐ«м­® ў ⮬ Ї®ап¤ЄҐ,
ў Є®в®а®¬ ®­Ё § ЇЁб ­л.

/* ЋЃљџ‚‹џ…Њ „‚… Џ…ђ…Њ…ЌЌ›… */
int x, y; /* 0 */

/* ќв® ҐйҐ ­Ґ ®ЇҐа в®ал, е®вп ЇаЁ н⮬ ᮧ¤ овбп 2 пйЁЄ  ¤«п
楫ле зЁбҐ«
*/

/* Ђ ’…Џ…ђњ - ЋЏ…ђЂ’Ћђ›. */
/* Њл ­ з­Ґ¬ б Їа®бвле ®ЇҐа в®а®ў ЇаЁбў Ёў ­Ёп Ё  аЁд¬ҐвЁЄЁ */

x = 3; /* 1 */
y = 4; /* 2 */
x = x + y; /* 3 */
y = y - 1; /* 4 */
x = y; /* 5 */

‡­ зҐ­Ёп ЇҐаҐ¬Ґ­­ле (в®, зв® «Ґ¦Ёв ў пйЁЄ е) ¬Ґ­повбп в ЄЁ¬ ®Ўа §®¬:

x y
/* 0 */ ¬гб®а ¬гб®а

/* Ї®б«Ґ 1 */ 3 ¬гб®а
/* Ї®б«Ґ 2 */ 3 4
/* Ї®б«Ґ 3 */ 7 4
/* Ї®б«Ґ 4 */ 7 3
/* Ї®б«Ґ 5 */ 3 3

Љ Є ўл ўЁ¤ЁвҐ, ЇҐаҐ¬Ґ­­лҐ, Є®в®алҐ ­Ґ гз бвўгов ў «Ґў®© з бвЁ ®ЇҐа в®а 
ЇаЁбў Ёў ­Ёп, нвЁ¬ ®ЇҐа в®а®¬ Ќ… Њ…Ќџћ’‘џ.

Џ®б«Ґ¤­пп ®ЇҐа жЁп x = y; Ќ… ¤Ґ« Ґв Ё¬Ґ­  x Ё y бЁ­®­Ё¬ ¬Ё.
’ Є®© ўҐйЁ, Є Є "ЇҐаҐўҐиЁў ­ЁҐ в Ў«ЁзҐЄ б Ё¬Ґ­ ¬Ё б пйЁЄ  ­  пйЁЄ"
­Ґ Їа®Ёб室Ёв. ‚¬Ґбв® нв®Ј®, ¤ў  пйЁЄ  б Ё¬Ґ­ ¬Ё x Ё y ᮤҐа¦ в
®¤Ё­ Є®ўлҐ §­ зҐ­Ёп, в® Ґбвм ¤ўҐ Є®ЇЁЁ ®¤­®Ј® Ё в®Ј® ¦Ґ зЁб« .

----- -----
/ x / / y /
--------------- ---------------
| 3 *<--|--------<----|-- 3 |
--------------- 1) ---------------
2), 3) 4)

1) €§ пйЁЄ  y ЎҐаҐвбп ЉЋЏ€џ зЁб«  3 (ЎҐ§л¬п­­®Ґ §­ зҐ­ЁҐ).
2) ‘в а®Ґ ᮤҐа¦Ё¬®Ґ пйЁЄ  x г­Ёз⮦ Ґвбп.
3) —Ёб«® 3 Є« ¤Ґвбп ў пйЁЄ x.
4) ‚ Ёб室­®¬ пйЁЄҐ y Ї®ЇаҐ¦­Ґ¬г ®бв «®бм 3.

‡­ зҐ­ЁҐ 楫®© ЇҐаҐ¬Ґ­­®© ¬®¦­® ўлўҐбвЁ ­  нЄа ­ ®ЇҐа в®а®¬ ЇҐз вЁ:

printf("%d\n", x);

Џ®Є  Ўг¤Ґ¬ а бб¬ ваЁў вм ҐЈ® Є Є "¬ ЈЁзҐбЄЁ©".

Ќ ¤ 楫묨 зЁб« ¬Ё ¬®¦­® Їа®Ё§ў®¤Ёвм в ЄЁҐ  аЁд¬ҐвЁзҐбЄЁҐ ®ЇҐа жЁЁ:

x + y б«®¦Ґ­ЁҐ
x - y ўлзЁв ­ЁҐ
x * y г¬­®¦Ґ­ЁҐ
x / y ¤Ґ«Ґ­ЁҐ ­ жҐ«® (в® Ґбвм б ®бв вЄ®¬; १г«мв в - 楫®Ґ)
x % y ўлзЁб«Ёвм ®бв в®Є ®в ¤Ґ«Ґ­Ёп ­ жҐ«®

5 / 2 ¤ бв 2
5 % 2 ¤ бв 1

‚ ®ЇҐа в®а е ЇаЁбў Ёў ­Ёп ЁбЇ®«м§говбп в ЄЁҐ б®Єа йҐ­Ёп:

„‹€ЌЌЂџ ‡ЂЏ€‘њ ‘Њ›‘‹ ‘ЋЉђЂ™Ђ…’‘џ „Ћ
x = x + 1; "㢥«ЁзЁвм ­  1" x++; (Ё«Ё ++x; )
x = x - 1; "㬥­миЁвм ­  1" x--; (Ё«Ё --x; )
x = x + y; "ЇаЁЎ ўЁвм y" x += y;
x = x * y; "г¬­®¦Ёвм ­  y" x *= y;
x = x / y; "Ї®¤Ґ«Ёвм ­  y" x /= y;

‚ ⮬ зЁб«Ґ x++; ¬®¦­® § ЇЁб вм Є Є x += 1;

* ‘’ђ“Љ’“ђ› “ЏђЂ‚‹…Ќ€џ *

ЋЎлз­® ®ЇҐа в®ал ўлЇ®«­повбп Ї®б«Ґ¤®ў вҐ«м­®,
ў ⮬ Ї®ап¤ЄҐ, ў Є®в®а®¬ ®­Ё § ЇЁб ­л ў Їа®Ја ¬¬Ґ.

®ЇҐа в®а1; |
®ЇҐа в®а2; |
®ЇҐа в®а3; |
®ЇҐа в®а4; V

“‘‹Ћ‚Ќ›‰ ЋЏ…ђЂ’Ћђ

if(гб«®ўЁҐ) ®ЇҐа в®а;

...Їа®¤®«¦Ґ­ЁҐ...

ђ Ў®в Ґв в Є:

‚лзЁб«пҐвбп гб«®ўЁҐ.

…б«Ё ®­® ЁбвЁ­­®, в® ўлЇ®«­пҐвбп ®ЇҐа в®а,
§ вҐ¬ ўлЇ®«­пҐвбп Їа®¤®«¦Ґ­ЁҐ.

…б«Ё ®­® «®¦­®, в® ба §г ўлЇ®«­пҐвбп Їа®¤®«¦Ґ­ЁҐ,
  ®ЇҐа в®а ­Ґ ўлЇ®«­пҐвбп.

…б«Ё ­ ¬ ­ ¤® ўлЇ®«­Ёвм ЇаЁ ЁбвЁ­­®бвЁ гб«®ўЁп ­ҐбЄ®«мЄ® ®ЇҐа в®а®ў,
¬л ¤®«¦­л § Є«озЁвм Ёе ў бЄ®ЎЄЁ { ... } - нв® в Є ­ §лў Ґ¬л©
"б®бв ў­®© ®ЇҐа в®а".

if(гб«®ўЁҐ) {
®ЇҐа в®а1;
®ЇҐа в®а2;
...
}
Їа®¤®«¦Ґ­ЁҐ

Џ®б«Ґ } в®зЄ  б § Їпв®© Ќ… ‘’Ђ‚€’‘џ (¬®¦­® Ё Ї®бв ўЁвм, ­® ­Ґ ­г¦­®).

“б«®ў­л© ®ЇҐа в®а Ё§®Ўа ¦ ов ­  б奬 е в Є:

|
|
|
----------------
---| …‘‹€ гб«®ўЁҐ |----
| ---------------- |
| |
V V
ЁбвЁ­­® «®¦­®
| |
V |
------------ |
| ®ЇҐа в®а | |
------------ |
| |
------->-------<-------
|
|
V
Їа®¤®«¦Ґ­ЁҐ
|

€¬ҐҐвбп ўв®а п д®а¬ , б з бвмо "Ё­ зҐ":

if(гб«®ўЁҐ) ®ЇҐа в®а_Ґб«Ё_ЁбвЁ­­®;
else ®ЇҐа в®а_Ґб«Ё_«®¦­®;

"Ё«Ё в®, Ё«Ё ¤агЈ®Ґ" (­® ­Ґ ®Ў  ба §г)

|
|
|
----------------
---| …‘‹€ гб«®ўЁҐ |-----------
| ---------------- |
| |
V V
ЁбвЁ­­® «®¦­®
| |
V |
------------------------- -----------------------
| ®ЇҐа в®а_Ґб«Ё_ЁбвЁ­­® | | ®ЇҐа в®а_Ґб«Ё_«®¦­® |
------------------------- -----------------------
| |
------->-------<--------------
|
|
V
Їа®¤®«¦Ґ­ЁҐ
|

ЏаЁ¬Ґа1:

if(x > 10)
printf("€Єб Ў®«миҐ ¤ҐбпвЁ\n");

ЏаЁ¬Ґа2:

int x, y, z;

if(x < y) z = 1;
else z = 2;

“б«®ўЁп:

‚ Є зҐб⢥ гб«®ўЁ© ¬®Јгв ЁбЇ®«м§®ў вмбп ®ЇҐа в®ал ‘ђЂ‚Ќ…Ќ€џ
(ба ў­Ёў вм ¬®¦­® ЇҐаҐ¬Ґ­­лҐ, ўла ¦Ґ­Ёп, Є®­бв ­вл)

x < y ¬Ґ­миҐ
x > y Ў®«миҐ
x <= y ¬Ґ­миҐ Ё«Ё а ў­®
x >= y Ў®«миҐ Ё«Ё а ў­®
x == y а ў­®
x != y ­Ґ а ў­®

‚ᥠнвЁ ®ЇҐа в®ал ў Є зҐб⢥ १г«мв в  ®ЇҐа жЁЁ ба ў­Ґ­Ёп ўл¤ ов
1, Ґб«Ё ба ў­Ґ­ЁҐ ЁбвЁ­­®
0, Ґб«Ё ®­® «®¦­®.

’ ЄЁ¬ ®Ўа §®¬, ­  б ¬®¬ ¤Ґ«Ґ гб«®ў­л© ®ЇҐа в®а а Ў®в Ґв в Є:

if(гб«®ўЁҐ) ....

…б«Ё гб«®ўЁҐ Ґбвм ЌЋ‹њ - в® гб«®ўЁҐ бзЁв Ґвбп «®¦­л¬.
…б«Ё гб«®ўЁҐ Ґбвм Ќ… ЌЋ‹њ   ... -2, -1, 1, 2, 3, ... - в® гб«®ўЁҐ ЁбвЁ­­®.

ќв® ®ЇаҐ¤Ґ«Ґ­ЁҐ.

€§ ­ҐЈ® ў з бв­®бвЁ ўл⥪ Ґв, зв® ба ў­Ґ­ЁҐ б жҐ«л¬ ­г«Ґ¬ ¬®¦­® ®ЇгбЄ вм:

if(x != 0) ... ; б®Єа й Ґвбп ¤® if(x) ... ;
if(x == 0) ... ; б®Єа й Ґвбп ¤® if(!x) ... ;
---------------------------------------------------------------------------

ЏаЁ¬Ґа:

int x, y, z;

if(x == 1){ y = 2; z = x + y; }
else { y = 1; z = x - y; }

---------------------------------------------------------------------------

ЏаЁ¬Ґа б® ў«®¦Ґ­­л¬Ё гб«®ў­л¬Ё ®ЇҐа в®а ¬Ё:

if(x == 1){
printf("€Єб а ўҐ­ 1\n");
if(y == 2){
printf("€ЈаҐЄ а ўҐ­ 2\n");
}
} else {
printf("€Єб ­Ґ а ўҐ­ 1\n");
}
---------------------------------------------------------------------------

— бв® ЇаЁ¬Ґ­пҐвбп Ї®б«Ґ¤®ў вҐ«м­®бвм гб«®ў­ле ®ЇҐа в®а®ў,
ЇҐаҐЎЁа ой п а §«Ёз­лҐ ў аЁ ­вл:

if(x == 1)
printf("€Єб а ўҐ­ 1\n");
else if(x == 2)
printf("€Єб а ўҐ­ 2\n");
else if(x == 3){
printf("€Єб а ўҐ­ 3\n");
y = 1;
} else
printf("ЌҐЇаҐ¤гᬮв७­®Ґ §­ зҐ­ЁҐ ЁЄб\n");
---------------------------------------------------------------------------

‘ ¬®Ґ б«®¦­®Ґ - ЇаЁўлЄ­гвм Є ⮬г, зв® ба ў­Ґ­ЁҐ ®Ў®§­ з Ґвбп §­ Є®¬ ==,
  ­Ґ =
‡­ Є = ®§­ з Ґв "ЇаЁбў®Ёвм §­ зҐ­ЁҐ",   ­Ґ "ба ў­Ёвм ­  а ўҐ­бвў®".

–€Љ‹ while ("¤® вҐе Ї®а, Ї®Є  ЁбвЁ­­®")

while(гб«®ўЁҐ)
®ЇҐа в®а;
...Їа®¤®«¦Ґ­ЁҐ...

Ё«Ё

while(гб«®ўЁҐ){
®ЇҐа в®ал;
...
}
...Їа®¤®«¦Ґ­ЁҐ...

|
V
|
+------>--+
| |
| V
Џ | ---------------------
® | | Їа®ўҐаЁвм “‘‹Ћ‚€… |-------> Ґб«Ё «®¦­® (­г«м)
ў A --------------------- |
в | | |
® | V |
а | Ґб«Ё ЁбвЁ­­® (­Ґ ­г«м) |
Ё | | |
в | V |
м | ®ЇҐа в®а V
| | |
| | |
+-----<---+ |
|
+-------<---------------------+
|
V
Їа®¤®«¦Ґ­ЁҐ

ЏаЁ¬Ґа:
int x;

x = 10;
while(x > 0){
printf("x=%d\n", x);
x = x - 1;
}
printf("Љ®­Ґж.\n");
printf("x бв «® а ў­® %d.\n", x); /* ЇҐз в Ґв 0 */

"–ЁЄ«" ®­ Ї®в®¬г, зв® ҐЈ® ⥫® Ї®ўв®апҐвбп ­ҐбЄ®«мЄ® а §.

—в®Ўл жЁЄ« ®Є®­зЁ«бп, ®ЇҐа в®а-⥫® жЁЄ«  ¤®«¦Ґ­ ¬Ґ­пвм
Є Єго-в® ЇҐаҐ¬Ґ­­го, ®в Є®в®а®© § ўЁбЁв ЁбвЁ­­®бвм гб«®ўЁп Ї®ўв®аҐ­Ё©.

ЋЏ…ђЂ’Ћђ› "€, €‹€, Ќ…"

“б«®ўЁп ¬®Јгв Ўлвм б«®¦­л¬Ё.

…‘‹€ Єа б­л© € ўҐб < 10 ’Ћ ...;
…‘‹€ Єа б­л© €‹€ бЁ­Ё© ’Ћ ...;
…‘‹€ Ќ… Єа б­л© ’Ћ ...;

Ќ  п§лЄҐ ‘Ё в ЄЁҐ гб«®ўЁп § ЇЁблў овбп в Є:

if(гб«®ўЁҐ1 && гб«®ўЁҐ2) ...; /* "€" */
if(гб«®ўЁҐ1 || гб«®ўЁҐ2) ...; /* "€‹€" */
if(! гб«®ўЁҐ1) ...; /* "Ќ…" */

Ќ ЇаЁ¬Ґа:

if(4 < x && x <= 12) ...;

Ѓл«® Ўл ­ҐЇа ўЁ«м­® § ЇЁб вм

if(4 < x <= 12) ...;

ЁЎ® п§лЄ Їа®Ја ¬¬Ёа®ў ­Ёп ‘Ё Ќ… ЏЋЌ€ЊЂ…’ ¤ў®©­®Ґ ба ў­Ґ­ЁҐ!

…йҐ ЇаЁ¬Ґал:

if(x < 3 || y > 4) ...;

if( ! (x < 3 || y > 4)) ...;

–€Љ‹ for ("¤«п Є ¦¤®Ј®")

ќв®в жЁЄ« пў«пҐвбп Їа®бв® Ё­®© § ЇЁбмо ®¤­®Ј® Ё§ ў аЁ ­в®ў жЁЄ«  while.
Ћ­ б«г¦Ёв ®Ўлз­® ¤«п ўлЇ®«­Ґ­Ёп ®ЇҐаҐ¤Ґ«Ґ­­®Ј® ¤Ґ©бвўЁп ­ҐбЄ®«мЄ® а §,
­Ґ "Ї®Є  ЁбвЁ­­® гб«®ўЁҐ",   "ўлЇ®«­Ёвм N-а §".

“ в Є®Ј® жЁЄ«  Ґбвм "ЇҐаҐ¬Ґ­­ п жЁЄ« " Ё«Ё "бзҐвзЁЄ Ї®ўв®аҐ­Ё©".

int i;

i = a; /* ­ з «м­ п Ё­ЁжЁ «Ё§ жЁп */

while(i < b){

⥫®_жЁЄ« ;

i += c; /* 㢥«ЁзҐ­ЁҐ бзҐвзЁЄ  */
}
...Їа®¤®«¦Ґ­ЁҐ...

ЇҐаҐЇЁблў Ґвбп ў ўЁ¤Ґ

int i;

for(i=a; i < b; i += c)
⥫®_жЁЄ« ;

⥫®_жЁЄ«  Ўг¤Ґв ўлЇ®«­Ґ­® ¤«п §­ зҐ­Ё© i
a
a+c
a+c+c
...

Ї®Є  i < b

‚ Їа®б⥩襬 б«гз Ґ

for(i=1; i <= N; i++)
printf("i=%d\n", i);

i ®§­ з Ґв "­®¬Ґа Ї®ўв®аҐ­Ёп".

’ Є®© жЁЄ« б«г¦Ёв ¤«п Ї®ўв®аҐ­Ёп ‘•Ћ†€• ¤Ґ©бвўЁ© Ќ…‘ЉЋ‹њЉЋ а §
б а §­л¬ §­ зҐ­ЁҐ¬ Ї а ¬Ґва .

ЋЏ…ђЂ’Ћђ break ("ўлў «Ёвмбп Ё§ жЁЄ« ")

ЋЇҐа в®а break § бв ў«пҐв ЇаҐаў вм ўлЇ®«­Ґ­ЁҐ ⥫  жЁЄ« 
Ё ба §г ЇҐаҐ©вЁ Є Їа®¤®«¦Ґ­Ёо Їа®Ја ¬¬л.

while(гб«®ўЁҐ1){
®ЇҐа в®ал1;

if(гб«®ўЁҐ2)
break; ------->----+
|
®ЇҐа в®ал2; |
} |
...Їа®¤®«¦Ґ­ЁҐ...<--------<---------+

Ё

for(i=0; гб«®ўЁҐ1; i++){
®ЇҐа в®ал1;

if(гб«®ўЁҐ2)
break; ------->----+
|
®ЇҐа в®ал2; |
} |
...Їа®¤®«¦Ґ­ЁҐ...<--------<---------+

ќв®в ®ЇҐа в®а Ї®§ў®«пҐв ®аЈ ­Ё§®ўлў вм ¤®Ї®«­ЁвҐ«м­лҐ
в®зЄЁ ўл室  Ё§ жЁЄ«  (ЇаЁ ¤®Ї®«­ЁвҐ«м­ле гб«®ўЁпе).

ЏаЁ¬Ґа:

for(i=0; i < 20; i++){
printf("i=%d\n", i);
if(i == 7){
printf("break loop!\n");
break; /* ўлў «Ёвмбп Ё§ жЁЄ«  */
}
printf("more\n");
}
printf("finished, i=%d\n", i); /* ЇҐз в Ґв 7 */

‚ з бв­®бвЁ, б ҐЈ® Ї®¬®ймо ¬®¦­® ®аЈ ­Ё§®ўлў вм ЎҐбЄ®­Ґз­л© жЁЄ«:

for(;;){ /* § Ј®«®ў®Є ЎҐбЄ®­Ґз­®Ј® жЁЄ«  */
®ЇҐа в®ал1;

if(гб«®ўЁҐ2)
break; ------->----+
|
®ЇҐа в®ал2; |
} |
...Їа®¤®«¦Ґ­ЁҐ...<--------<---------+

‡¤Ґбм ў б ¬®¬ § Ј®«®ўЄҐ жЁЄ«  Ќ… ЏђЋ‚…ђџ…’‘џ Ќ€ЉЂЉ€• “‘‹Ћ‚€‰,
в Є®© жЁЄ« Їа®¤®«¦ Ґвбп ЎҐбЄ®­Ґз­®.
“б«®ўЁҐ Їа®¤®«¦Ґ­Ёп бзЁв Ґвбп ўбҐЈ¤  ЁбвЁ­­л¬.

…¤Ё­б⢥­­л© бЇ®б®Ў ўл©вЁ Ё§ ­ҐЈ® -
н⮠ᤥ« вм break (ЇаЁ Є Є®¬-в® гб«®ўЁЁ) ў ⥫Ґ жЁЄ« , зв® Ё ­ ЇЁб ­®.

ЃҐбЄ®­Ґз­л© жЁЄ« ¬®¦­® в Є¦Ґ ®аЈ ­Ё§®ў вм ЇаЁ Ї®¬®йЁ
while(1){
...
}

ЋЏ…ђЂ’Ћђ ‚›‚Ћ„Ђ (Џ…—Ђ’€)

printf("⥪бв");

ЏҐз в Ґв ­  нЄа ­ ⥪бв.

printf("⥪бв\n");

ЏҐз в Ґв ­  нЄа ­ ⥪бв Ё ЇҐаҐе®¤Ёв Є ­®ў®© бва®ЄҐ.

printf("б«®ў®1 б«®ў®2 ");
printf("б«®ў®3\n");

ЇҐз в Ґв

б«®ў®1 б«®ў®2 б«®ў®3
Ё ЇҐаҐе®¤Ёв ­  ­®ўго бва®Єг.

…б«Ё ЇҐаҐе®¤ ­  ­®ўго бва®Єг ­Ґ § ¤ ­ пў­®, бЁ¬ў®«®¬ \n,
⮠⥪б⠯த®«¦ Ґв ЇҐз в вмбп ў ⥪г饩 бва®ЄҐ.

printf("%d", x);

ЏҐз в Ґв ў ⥪бв®ў®¬ ўЁ¤Ґ ‡ЌЂ—…Ќ€… ЇҐаҐ¬Ґ­­®© x.
‘ЇҐжЁ «м­ п Є®­бвагЄжЁп %d ®§­ з Ґв
"ў§пвм ЇҐаҐ¬Ґ­­го Ё§ бЇЁбЄ  Ї®б«Ґ § Їпв®©
Ё ­ ЇҐз в вм ҐҐ §­ зҐ­ЁҐ ў Ёў¤Ґ 楫®Ј® зЁб« ".

printf("ЁЄб а ўҐ­ %d - ®Ј®-Ј®\n", x);

ЏҐз в Ґв б­ з «  ⥪бв

ЁЄб а ўҐ­

§ вҐ¬ §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© x Є Є 楫®Ґ зЁб«®,
§ вҐ¬ ⥪бв
- ®Ј®-Ј®

Ё ЇҐаҐе®¤Ёв ­  ­®ўго бва®Єг (Ї®бЄ®«мЄг гЄ § ­ бЁ¬ў®« \n).

ќв®в ®ЇҐа в®а ¬®¦Ґв ЇҐз в вм Ё ­ҐбЄ®«мЄ® §­ зҐ­Ё© ЇҐаҐ¬Ґ­­ле:

int x, y;

x = 12; y = 15;
printf("ЁЄб Ґбвм %d, ЁЈаҐЄ Ґбвм %d, ўбҐ.\n", x, y);
~~~~~~

„ ­­л© ®ЇҐа в®а а Ў®в Ґв в Є.
‘ва®Є  "ЁЄб Ґбвм %d, ЁЈаҐЄ Ґбвм %d\n" ­ §лў Ґвбп ”ЋђЊЂ’ЋЊ.
Љ®¬ЇмовҐа зЁв Ґв д®а¬ в б«Ґў  ­ Їа ў® Ё ЇҐз в Ґв ⥪бв
¤® вҐе Ї®а, Ї®Є  ­Ґ ўбваҐвЁв бЁ¬ў®« %d.
Љгаб®а Ё§®Ўа ¦Ґ­ бЁ¬ў®«®¬ _

ЁЄб Ґбвм _

„ «ҐҐ ®­ ЎҐаҐв Џ…ђ‚“ћ ЇҐаҐ¬Ґ­­го Ё§ бЇЁбЄ  ~~~~ Ё
ЇҐз в Ґв ҐҐ Є Є 楫®Ґ зЁб«®.

ЁЄб Ґбвм 12_

¤ «ҐҐ ®­ б­®ў  ЇҐз в Ґв ⥪бв Ї®Є  ­Ґ ўбваҐвЁв %d

ЁЄб Ґбвм 12, ЁЈаҐЄ Ґбвм _

’ҐЇҐам ®­ ЎҐаҐв ‚’Ћђ“ћ ЇҐаҐ¬Ґ­­го Ё§ бЇЁбЄ  Ё ЇҐз в Ґв ҐҐ:

ЁЄб Ґбвм 12, ЁЈаҐЄ Ґбвм 15_

‘­®ў  ЇҐз в Ґв ⥪бв, ўЄ«оз п ЇҐаҐў®¤ бва®ЄЁ \n.
Љ Є в®«мЄ® бва®Є  д®а¬ в  Є®­зЁ« бм, ®ЇҐа в®а printf § ўҐа襭.

ЁЄб Ґбвм 12, ЁЈаҐЄ Ґбвм 15, ўбҐ.
_

ЏҐз в вм ¬®¦­® ­Ґ в®«мЄ® §­ зҐ­Ёп ЇҐаҐ¬Ґ­­ле, ­® Ё §­ зҐ­Ёп  аЁд¬ҐвЁзҐбЄЁе
ўла ¦Ґ­Ё©:

printf("а ў­®: %d\n", 12 + 3 * 5);

Љ®­ва®«м­л© ў®Їа®б, зв® ЇҐз в Ґвбп:

int x, y, z;

x = 13;
y = 23;
z = 34;

printf("x=%d xx=%d\nzzz=%d\n", x, y - 1, z * 2 + 1);

’гв ў д®а¬ вҐ Ґбвм „‚Ђ ЇҐаҐў®¤  бва®ЄЁ,
Ї®н⮬㠡㤥⠭ ЇҐз в ­®:

x=13 xx=22
zzz=69
_

‡ ¬ҐвмвҐ, зв® ЇҐаҐ¤ ⥬ Є Є Ўлвм ­ ЇҐз в ­­л¬Ё,
ўла ¦Ґ­Ёп ў бЇЁбЄҐ Ї®б«Ґ д®а¬ в  ‚›—€‘‹џћ’‘џ.

—в® ­ ЇҐз в Ґв

printf("x=%d\n y=%d\n", x, y);

x=13
y=23
_

Џа®ЎҐ« ЇҐаҐ¤ y ў®§­ЁЄ Ї®в®¬г, зв® ®­ ‘Ћ„…ђ†€’‘џ
ў бва®ЄҐ д®а¬ в  Ї®б«Ґ бЁ¬ў®«  \n !!!
Ѓг¤м⥠ў­Ё¬ вҐ«м­л.

”“ЌЉ–€€

”г­ЄжЁҐ© ­ §лў Ґвбп да Ј¬Ґ­в Їа®Ја ¬¬л,
ў Є®в®ал© ЇҐаҐ¤ овбп ЏЂђЂЊ…’ђ›,
Ё Є®в®ал© ‚Ћ‡‚ђЂ™Ђ…’ §­ зҐ­ЁҐ (Ё«Ё ­ЁзҐЈ®).

ЏаҐ«Ґбвм дг­ЄжЁЁ ў ⮬, зв® ҐҐ ¬®¦­® ўлЇ®«­Ёвм ¬­®Ј® а §
Ё§ а §­ле в®зҐЄ Їа®Ја ¬¬л.

”г­ЄжЁп б®бв®Ёв Ё§

ЋЃљџ‚‹…Ќ€џ - ®ЇЁб ­Ёп в®Ј®, Є Є ®­  зв®-в® ўлзЁб«пҐв
ЋЎкпў«Ґ­ЁҐ Ўлў Ґв а®ў­® ®¤­®.

‚›‡Ћ‚Ћ‚ - б Є®­ЄаҐв­л¬Ё §­ зҐ­Ёп¬Ё Ї а ¬Ґва®ў,
зв® Ё¬Ґ­­® ®­  ¤®«¦­  ­  нв®в а § ўлзЁб«Ёвм.
‚맮ў®ў ¬®¦Ґв Ўлвм бЄ®«мЄ® гЈ®¤­®.

ЋЎкпў«Ґ­ЁҐ Їа®б⥩襩 дг­ЄжЁЁ ўлЈ«п¤Ёв в Є:

int func(int x){

/* Ћ¤Ё­ Ё«Ё ­ҐбЄ®«мЄ® ®ЇҐа в®а®ў,
§ ўҐаи ойЁебп ®ЇҐа в®а®¬ return(­Ґзв®);
*/

return x+1;
}

---------------------------------------------------------------------------

int func(...

§ ¤ Ґв дг­ЄжЁо б Ё¬Ґ­Ґ¬ func
(Ё¬п ўл¤г¬лў Ґв Їа®Ја ¬¬Ёбв, Є Є Ё Ё¬Ґ­  ЇҐаҐ¬Ґ­­ле).

int ®§­ з Ґв, зв® дг­ЄжЁп ў®§ўа й Ґв 楫®Ґ §­ зҐ­ЁҐ.
---------------------------------------------------------------------------

...(int x)...

§ ¤ Ґв бЇЁб®Є  аЈг¬Ґ­в®ў (Ё«Ё Ї а ¬Ґва®ў) дг­ЄжЁЁ.
---------------------------------------------------------------------------

...){
...
}

§ ¤ Ґв ⥫® дг­ЄжЁЁ - ­ҐЄго Ї®б«Ґ¤®ў вҐ«м­®бвм ®Ўкпў«Ґ­Ё©
ЇҐаҐ¬Ґ­­ле Ё ®ЇҐа в®а®ў.
---------------------------------------------------------------------------

return ўла ¦Ґ­ЁҐ;

§ ¤ Ґв ®ЇҐа в®а ўл室  Ё§ дг­ЄжЁЁ ў в®зЄг ҐҐ ўл§®ў  б ў®§ўа в®¬ §­ зҐ­Ёп
ўла ¦Ґ­Ёп.
---------------------------------------------------------------------------

Џ®Є ¦Ґ¬ Їа®бв®© ЇаЁ¬Ґа ‚›‡Ћ‚Ђ нв®© дг­ЄжЁЁ:

int y;
...
y = func(5); /* a */
...Їа®¤®«¦Ґ­ЁҐ... /* b */

ќв®в да Ј¬Ґ­в а Ў®в Ґв б«Ґ¤гойЁ¬ ®Ўа §®¬:

y = func(5);

‚ нв®© в®зЄҐ ¬л
1) "§ ЇЁблў Ґ¬ ­  Ўг¬ ¦ЄҐ",
зв® ўл§®ў Їа®Ё§®иҐ« ў в Є®©-в® бва®ЄҐ, в Є®¬-в® ¬ҐбвҐ
­ иҐ© Їа®Ја ¬¬л.

2) ‘¬®ваЁ¬ ­  ЋЏђ…„…‹…Ќ€… дг­ЄжЁЁ func.

int func(int x){...

Њл ўл§ў «Ё дг­ЄжЁо Є Є func(5).
ќв® §­ зЁв, зв® ў ⥫Ґ дг­ЄжЁЁ x Ї®«гз Ґв ­ з «м­®Ґ §­ зҐ­ЁҐ 5.

’® Ґбвм „‹џ „ЂЌЌЋѓЋ ‚›‡Ћ‚Ђ ­ и  дг­ЄжЁп (ҐҐ ⥫®) ЇаҐўа й Ґвбп ў

int x;

x = 5;
return x+1;

3) x+1 Ґбвм 6.

„ «ҐҐ ¤®«¦Ґ­ ўлЇ®«­Ёвмбп ®ЇҐа в®а return.

Ћ­ ўлЇ®«­пҐвбп в Є:

Њл "зЁв Ґ¬ б Ўг¬ ¦ЄЁ" - ®вЄг¤  Ўл«  ўл§ў ­  дг­ЄжЁп func,
Ё ᬮваЁ¬ ­  нв® ¬Ґбв®. ќв® Ўл«®

y = func(5);

‚лзҐаЄЁў Ґ¬ func(5) Ё § ¬Ґ­пҐ¬ ҐЈ® ‡ЌЂ—…Ќ€…Њ ўла ¦Ґ­Ёп,
ўлзЁб«Ґ­­®Ј® ў ®ЇҐа в®аҐ return;

y = 6;

4) ‚лЇ®«­пҐ¬ нв®в ®ЇҐа в®а Ё ЇҐаҐе®¤Ё¬ Є Їа®¤®«¦Ґ­Ёо.

---------------------------------------------------------------------------

int y, z, w;

y = func(5);
z = func(6);
w = func(7) + func(8) + 1;

ЏаҐўа вЁвбп ў

y = 6;
z = 7;
w = 8 + 9 + 1;

ЏаЁ н⮬ ¬л зҐвлॠࠧ  "ЇалЈ­Ґ¬" ­  ®ЇаҐ¤Ґ«Ґ­ЁҐ дг­ЄжЁЁ func(),
Їа®©¤Ґ¬ ўбҐ ҐҐ ®ЇҐа в®ал б а §­л¬Ё §­ зҐ­Ёп¬Ё Ї а ¬Ґва  x
Ё ўҐа­Ґ¬бп ®Ўа в­® ў в®зЄг ўл§®ў .

ЏђЋѓђЂЊЊЂ ‚ –…‹ЋЊ

Џа®Ја ¬¬  ў 楫®¬ б®бв®Ёв Ё§ дг­ЄжЁ©.
Ћ¤­  Ё§ дг­ЄжЁ© ¤®«¦­  Ё¬Ґвм Ё¬п main(),

‘ ”“ЌЉ–€€ main ЌЂ—€ЌЂ…’‘џ ‚›ЏЋ‹Ќ…Ќ€… ЏђЋѓђЂЊЊ›.

(­  б ¬®¬ ¤Ґ«Ґ н⮬㠯।иҐбвўгҐв ®вўҐ¤Ґ­ЁҐ Ё Ё­ЁжЁ «Ё§ жЁп
Ј«®Ў «м­ле ЇҐаҐ¬Ґ­­ле; ᬮваЁ Ї®б«Ґ¤гойЁҐ «ҐЄжЁЁ).

— бв® main() - Ґ¤Ё­б⢥­­ п дг­ЄжЁп ў Їа®Ја ¬¬Ґ.

---------------------------------------------------------------------------

‘вагЄвга  Їа®Ја ¬¬л в Є®ў :

#include /* ¬ ЈЁзҐбЄ п бва®Є  */

/* ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›… (® ­Ёе Ї®§¦Ґ) */
int a = 7;
int b; /* Ї® 㬮«з ­Ёо 0 */

/* ”“ЌЉ–€€ */
f1(){....}
f2(){....}

/* ЌЂ—Ђ‹њЌЂџ (ѓ‹Ђ‚ЌЂџ) ”“ЌЉ–€џ */
void main(){
...
}
---------------------------------------------------------------------------

ЏаЁ¬Ґа Їа®Ја ¬¬л:

#include

int f1(int x, int y){
return (x + y*2);
}

int f2(int x){
int z;

z = x+7;
return 2*z;
}

void main(){
/* ЋЎкпў«Ґ­Ёп ЇҐаҐ¬Ґ­­ле */
int a, b, c;

/* ЋЇҐа в®ал */
a = 5; b = 6;

c = f1(a, b+3);
b = f1(1, 2);
a = f2(c);

printf("A Ґбвм %d B Ґбвм %d C Ґбвм %d\n", a, b, c);
}

Ћ­  ЇҐз в Ґв:

A Ґбвм 60 B Ґбвм 5 C Ґбвм 23

ЉЂЉ Ќ… ЌЂ„Ћ ЏђЋѓђЂЊЊ€ђЋ‚Ђ’њ –€Љ‹›

int i;

for(i=0; i < 4; i++){
if(i == 0) func0();
else if(i == 1) func1();
else if(i == 2) func2();
else if(i == 3) func3();
}

‚ ¤ ­­®¬ ЇаЁ¬ҐаҐ жЁЄ« ЂЃ‘Ћ‹ћ’ЌЋ Ќ… Ќ“†…Ќ.
’®, зв® вгв ¤Ґ« Ґвбп, Ґбвм Їа®бв® ЏЋ‘‹…„Ћ‚Ђ’…‹њЌЋ‘’њ ®ЇҐа в®а®ў:

func0();
func1();
func2();
func3();

–ЁЄ« Ё¬ҐҐв б¬лб« «Ёим в®Ј¤ , Є®Ј¤  ¬­®Ј® а § ўл§лў Ґвбп
Ћ„ЌЋ € ’Ћ †… ¤Ґ©бвўЁҐ, ­® ¬®¦Ґв Ўлвм § ўЁбп饥 ®в Ї а ¬Ґва , ўа®¤Ґ func(i).
Ќ® ­Ґ а §­лҐ дг­ЄжЁЁ ¤«п а §­ле i.

Ђ­ «®ЈЁз­®, а бᬮваЁ¬ в Є®© ЇаЁ¬Ґа:

int i;

for(i=0; i < 10; i++){
if(i==0) func0();
else if(i == 1) func1();
else if(i == 2) func2();
else funcN(i);
}

’гв funcN(i) ЎҐаҐв ­  ᥡп а®«м "  ў ®бв «м­ле б«гз пе".
Ћ¤­ Є®, нв®в ЇаЁ¬Ґа Ў®«ҐҐ ҐбвҐб⢥­­® ¬®¦Ґв Ўлвм § ЇЁб ­ в Є:

int i;

func0();
func1();
func2();
for(i = 3; i < 10; i++)
funcN(i);

‡ ¬ҐвмвҐ, зв® жЁЄ« ⥯Ґам ­ зЁ­ Ґвбп б Ё­¤ҐЄб  3.

Ђ ⥯Ґам - б«гз ©, Ј¤Ґ ᬥбм жЁЄ«  Ё гб«®ў­®Ј® ®ЇҐа в®а  ®Їа ў¤ ­ :

int i;

for(i=0; i < 100; i++){
if((i % 2) == 0) even(); /* зҐв­л© */
else odd(); /* ­ҐзҐв­л© */
}

’гв ў жЁЄ«Ґ Їа®ўҐапҐвбп зҐв­®бвм Ё­¤ҐЄб  i.
03.c

/* ’аҐгЈ®«м­ЁЄ Ё§ §ўҐ§¤®зҐЄ */

#include

/* putchar('c') - ЇҐз в Ґв ®¤Ё­®ЄЁ© бЁ¬ў®« c */
/* бЁ¬ў®« \n - ЇҐаҐў®¤Ёв бва®Єг */
/* nstars - бЄ®«мЄ® §ўҐ§¤®зҐЄ ­ ЇҐз в вм */

/* ”г­ЄжЁп аЁб®ў ­Ёп ®¤­®© бва®ЄЁ ваҐгЈ®«м­ЁЄ  */
void drawOneLine(int nstars){
int i; /* ­®¬Ґа ЇҐз в Ґ¬®© §ўҐ§¤®зЄЁ, бзҐвзЁЄ */

for(i=0; i < nstars; i++) /* ђЁб㥬 nstars §ўҐ§¤®зҐЄ Ї®¤ап¤ */
putchar('*');
putchar('\n'); /* € ЇҐаҐе®¤Ё¬ ­  б«Ґ¤гойго бва®Єг */
}

void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int nline; /* ­®¬Ґа бва®ЄЁ */

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=1; nline <= 25; nline++)
drawOneLine(nline);
/* бЄ®«мЄ® §ўҐ§¤®зҐЄ? бв®«мЄ® ¦Ґ, Є Є®ў ­®¬Ґа бва®ЄЁ */
}
04.c

/* ’аҐгЈ®«м­ЁЄ Ё§ §ўҐ§¤®зҐЄ */
/* ’®в ¦Ґ ЇаЁ¬Ґа б® ў«®¦Ґ­­л¬ жЁЄ«®¬,   ­Ґ б дг­ЄжЁҐ© */

#include

void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int nline; /* ­®¬Ґа бва®ЄЁ */
int i; /* ­®¬Ґа ЇҐз в Ґ¬®© §ўҐ§¤®зЄЁ, бзҐвзЁЄ */

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=1; nline <= 25; nline++){
/* бЄ®«мЄ® §ўҐ§¤®зҐЄ? бв®«мЄ® ¦Ґ, Є Є®ў ­®¬Ґа бва®ЄЁ */
for(i=0; i < nline; i++)
putchar('*');
putchar('\n');
}
}
05.c

/* ’аҐгЈ®«м­ЁЄ Ё§ §ўҐ§¤®зҐЄ */
/* ’ҐЇҐам ваҐгЈ®«м­ЁЄ ¤®«¦Ґ­ Ўлвм а ў­®ЎҐ¤аҐ­­л¬ */

#include

/* nstars - бЄ®«мЄ® §ўҐ§¤®зҐЄ ­ ЇҐз в вм */
/* nspaces - бЄ®«мЄ® Їа®ЎҐ«®ў ­ ЇҐз в вм ЇҐаҐ¤ §ўҐ§¤®зЄ ¬Ё */

void drawOneLine(int nspaces, int nstars){
int i; /* ­®¬Ґа ЇҐз в Ґ¬®© §ўҐ§¤®зЄЁ, бзҐвзЁЄ */
/* ®­ ¦Ґ - ­®¬Ґа ЇҐз в Ґ¬®Ј® Їа®ЎҐ«  */

for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nstars; i++)
putchar('*');
putchar('\n');
}

/*
n (­®¬Ґа бва®ЄЁ)
...* 1
..*** 2
.***** 3
******* 4

‚ᥣ® бва®Є: LINES
—Ёб«® §ўҐ§¤®зҐЄ ў n-®© бва®ЄҐ: n*2 - 1
—Ёб«® Їа®ЎҐ«®ў ᯥ।Ё (®Ў®§­ зҐ­л в®зЄ®©): LINES - n

‚ᥠнвЁ зЁб«  Ї®¤бзЁвлў овбп б Є авЁ­ЄЁ...

€е ¬л Ўг¤Ґ¬ ЇҐаҐ¤ ў вм ў дг­ЄжЁо drawOneLine ў в®зЄҐ _ўл§®ў _,
  ­Ґ ўлзЁб«пвм ў б ¬®© дг­ЄжЁЁ. ”г­ЄжЁп ¤«п в®Ј® Ё § ўҐ¤Ґ­ ,
зв®Ўл ­Ґ ўлзЁб«пвм ­ЁзҐЈ® ЉЋЌЉђ…’ЌЋѓЋ -
ўбҐ Ї а ¬Ґвал ҐҐ ЇҐаҐ¬Ґ­­лҐ, Ё ¤®«¦­л Џ…ђ…„Ђ‚Ђ’њ‘џ ў ­ҐҐ
Ё§ в®зЄЁ ўл§®ў .

‚ Є зҐб⢥ Ї а ¬Ґва  ў в®зЄҐ ўл§®ў  ¬®¦­® ЇҐаҐ¤ ў вм ­Ґ
в®«мЄ® §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®©, ­® Ё §­ зҐ­ЁҐ ўла ¦Ґ­Ёп,
в® Ґбвм д®а¬г«л.

*/
void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int LINES = 25; /* ўбҐЈ® бва®Є.
ќв® ®ЇЁб ­ЁҐ ЇҐаҐ¬Ґ­­®©
ба §г б ҐҐ Ё­ЁжЁ «Ё§ жЁҐ©
*/
int nline; /* ­®¬Ґа бва®ЄЁ */

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=1; nline <= LINES; nline++)
drawOneLine(LINES - nline, /* зЁб«® Їа®ЎҐ«®ў --> nspaces */
nline*2 - 1 /* зЁб«® §ўҐ§¤®зҐЄ --> nstars */
);
}
06.c

/* ’аҐгЈ®«м­ЁЄ Ё§ §ўҐ§¤®зҐЄ */
/* ’ҐЇҐам ваҐгЈ®«м­ЁЄ ¤®«¦Ґ­ Ўлвм а ў­®ЎҐ¤аҐ­­л¬ */

#include

void drawOneLine(int nspaces, int nstars){
int i; /* ­®¬Ґа ЇҐз в Ґ¬®© §ўҐ§¤®зЄЁ, бзҐвзЁЄ */
/* ®­ ¦Ґ - ­®¬Ґа ЇҐз в Ґ¬®Ј® Їа®ЎҐ«  */

for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nstars; i++)
putchar('*');
putchar('\n');
}

void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int LINES = 25; /* ўбҐЈ® бва®Є. */
int nline; /* ­®¬Ґа бва®ЄЁ */

/* „«п 祫®ўҐЄ  ҐбвҐб⢥­­® бзЁв вм б 1.
„«п ¬ иЁ­л ¦Ґ ЇҐаў®Ґ зЁб«® - нв® Ќ“‹њ.
Џ®н⮬г жЁЄ«
for(nline=1; nline <= LINES; nline++)
‘«Ґ¤гҐв § ЇЁб вм ў ўЁ¤Ґ
for(nline=0; nline < LINES; nline++)

Ћ­ ⮦Ґ ўлЇ®«­Ёвбп 25 а §, ­® §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®©-бзҐвзЁЄ 
nline Ўг¤Ґв ­  Є ¦¤®© ЁвҐа жЁЁ ­  1 ¬Ґ­миҐ. Џ®н⮬㠭 ¤®
Ї®¬Ґ­пвм а бзҐв Ї а ¬Ґва®ў ¤«п дг­ЄжЁЁ аЁб®ў ­Ёп.

n (­®¬Ґа бва®ЄЁ)
...* 0
..*** 1
.***** 2
******* 3

‚ᥣ® бва®Є: LINES
—Ёб«® §ўҐ§¤®зҐЄ ў n-®© бва®ЄҐ: n*2 + 1
—Ёб«® Їа®ЎҐ«®ў ᯥ।Ё (®Ў®§­ зҐ­л в®зЄ®©): LINES - n - 1

*/

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=0; nline < LINES; nline++)
drawOneLine(LINES - nline - 1, nline*2 + 1);
}
07.c

/*
’ЁЇ ЇҐаҐ¬Ґ­­ле ¤«п еа ­Ґ­Ёп Ѓ“Љ‚ ­ §лў Ґвбп

char

(®в б«®ў  character).

ЃгЄўл Ё§®Ўа ¦ овбп ў ®¤Ё­®з­ле Є ўлзЄ е 'a' 'b' '+'.

ЏаЁ¬Ґа:
char letter;

letter = 'a';
putchar(letter);
letter = 'b';
putchar(letter);
letter = '\n';
putchar(letter);

‘Ё¬ў®« '\n' ®Ў®§­ з Ґв "­ҐўЁ¤Ё¬го ЎгЄўг" -
ЇҐаҐе®¤ ­  ­®ўго бва®Єг, new line.
…бвм ­ҐбЄ®«мЄ® в ЄЁе бЇҐжЁ «м­ле ЎгЄў, ® ­Ёе - Ї®§¦Ґ.

‡ в® ба §г ᤥ« Ґ¬ ®Ј®ў®аЄг.
—в®Ўл Ё§®Ўа §Ёвм б ¬г ЎгЄўг \
б«Ґ¤гҐв ЁбЇ®«м§®ў вм '\\'

putchar('\'); Ё«Ё
printf ("\"); ®иЁЎ®з­л.

Ќ ¤®: putchar('\\'); printf("\\");

„Ґ«® ў ⮬, зв® бЁ¬ў®« \ ­ зЁ­ Ґв Ї®б«Ґ¤®ў вҐ«м­®бвм Ё§ „‚“• ЎгЄў,
Ё§®Ўа ¦ ойЁе Ћ„Ќ“ ЎгЄўг, Ё­®Ј¤  ўл§лў ойго бЇҐжЁ «м­лҐ
¤Ґ©бвўЁп ­  нЄа ­Ґ Ё«Ё ­  ЇаЁ­вҐаҐ.
*/

/*
—Ёб«® ¤Ґ«Ёвбп ­  n, Ґб«Ё Ћ‘’Ђ’ЋЉ ®в ¤Ґ«Ґ­Ёп ҐЈ® ­  n а ўҐ­ 0,
в® Ґбвм Ґб«Ё

(x % n) == 0

‚ з бв­®бвЁ, в Є ¬®¦­® Їа®ўҐапвм зЁб«  ­  зҐв­®бвм/­ҐзҐв­®бвм,
ЎҐап x%2.

Ћбв вЄЁ ®в ¤Ґ«Ґ­Ёп зЁб«  x ­  n
нв® 0 1 2 ... n-1.
‚ б«гз Ґ ¤Ґ«Ґ­Ёп ­  2 ®бв в®Є
0 ᮮ⢥вбвўгҐв зҐв­®¬г x
1 ᮮ⢥вбвўгҐв ­ҐзҐв­®¬г x

*/

/* ‡ ¤ з :
Ќ аЁб®ў вм ваҐгЈ®«м­ЁЄ
Ё§ §ўҐ§¤®зҐЄ ў ­ҐзҐв­ле бва®Є е
Ё§ Ї«обЁЄ®ў ў зҐв­ле бва®Є е
*--------------------------------------------------------*

ђҐиҐ­ЁҐ: ЁбЇ®«м§гҐ¬ ЇаҐ¦­оо Їа®Ја ¬¬г,
¤®Ў ўЁў ў дг­ЄжЁо drawOneLine ҐйҐ ®¤Ё­  аЈг¬Ґ­в - symbol -
Є ЄЁ¬ бЁ¬ў®«®¬ аЁб®ў вм бва®Єг.

„ «ҐҐ ў ®б­®ў­®¬ жЁЄ«Ґ ЁбЇ®«м§гҐ¬ гб«®ў­л© ®ЇҐа в®а Ё
Їа®ўҐаЄг ­®¬Ґа  бва®ЄЁ ­  зҐв­®бвм.

*/

#include

void drawOneLine(int nspaces, int nsymbols, char symbol){
int i; /* бзҐвзЁЄ */

for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nsymbols; i++)
putchar(symbol);
putchar('\n');
}

/* Њл ўл­ҐбҐ¬ ®Ўкпў«Ґ­ЁҐ нв®© ЇҐаҐ¬Ґ­­®© Ё§ дг­ЄжЁЁ,
ᤥ« ў ҐҐ "Ј«®Ў «м­®©", в® Ґбвм ўЁ¤Ё¬®© ў® ‚‘…• дг­ЄжЁпе.
*/
int LINES = 25; /* ўбҐЈ® бва®Є. */

void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int nline; /* ­®¬Ґа бва®ЄЁ */

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=0; nline < LINES; nline++){

if((nline % 2) == 0) /* зҐв­®Ґ ? */
drawOneLine(LINES - nline - 1, nline*2 + 1, '+');
else drawOneLine(LINES - nline - 1, nline*2 + 1, '*');
}
}
08.c

/* ’® ¦Ґ б ¬®Ґ, ­® ⥯Ґам ­г¦­® ҐйҐ Ё ЇҐз в вм ­®¬Ґа бва®ЄЁ.
*/

#include

/* ‚®®ЎйҐ-в® Ј«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ
ЇаЁ­пв® ®Ўкпў«пвм ў б ¬®¬ ­ з «Ґ д ©«  б Їа®Ја ¬¬®©.
*/

int LINES = 25; /* ўбҐЈ® бва®Є. */

/* „®Ў ўЁ¬ Є дг­ЄжЁЁ ҐйҐ ®¤Ё­  аЈг¬Ґ­в, гЄ § вҐ«м - ЇҐз в вм «Ё
­®¬Ґа бва®ЄЁ. Ќ §®ўҐ¬ ҐЈ® drawLineNumber.
ЌҐ ўЇ ¤ЁвҐ ў § Ў«г¦¤Ґ­ЁҐ Ї®  ­ «®ЈЁЁ б Ё¬Ґ­Ґ¬ ”“ЌЉ–€€ drawOneLine() !
‚ ¤ ­­®¬ б«гз Ґ - нв® Ё¬п Џ…ђ…Њ…ЌЌЋ‰ - Ђђѓ“Њ…Ќ’Ђ ”“ЌЉ–€€.

ЋЇҐа в®а if(x) .....;
ђЂЃЋ’Ђ…’ ’ЂЉ€Њ ЋЃђЂ‡ЋЊ (в Є ®­ гбв஥­):
ў Є зҐб⢥ гб«®ўЁп ®­ ЇаЁ­Ё¬ Ґв 楫®Ґ зЁб«® (вЁЇ  int).
“б«®ўЁҐ ЁбвЁ­­®, Ґб«Ё x != 0,
Ё «®¦­®, Ґб«Ё x == 0.

‚в®а®© ¤®Ў ў«Ґ­­л©  аЈг¬Ґ­в - б®Ўб⢥­­® ­®¬Ґа бва®ЄЁ.
*/
void drawOneLine(int nspaces,
int nsymbols,
char symbol,
/*   нв® ¬л ¤®Ў ўЁ«Ё */
int drawLineNumber,
int linenum
){
int i; /* бзҐвзЁЄ */

if(drawLineNumber)
printf("%d\t", linenum); /* ЎҐ§ ЇҐаҐў®¤  бва®ЄЁ */

/* Ќ  б ¬®¬ ¤Ґ«Ґ нв® гб«®ўЁҐ Ў®«ҐҐ Ї®«­® ­ ¤® § ЇЁблў вм Є Є

if(drawLineNumber != 0)

­® ў п§лЄҐ ‘Ё нв® в® ¦Ґ б ¬®Ґ.
*/

/* ’гв ¬л б­®ў  ўЁ¤Ё¬ ­®ўл© бЇҐжЁ «м­л© бЁ¬ў®« \t - ’ЂЃ“‹џ–€џ.
‚Ґбм нЄа ­ (Ё«Ё «Ёбв Ўг¬ ЈЁ) гб«®ў­® Ї®¤Ґ«Ґ­
­  Є®«®­ЄЁ иЁаЁ­®© Ї® 8 Ї®§ЁжЁ©.
ЏаЁ¬Ґа­® в Є:
| | | | | | | | | ...
‘Ё¬ў®« в Ўг«пжЁЁ ўл§лў Ґв ЇҐаҐе®¤ Ё§ ⥪г饩 Ї®§ЁжЁЁ ў ­ з «® б«Ґ¤го饩
Є®«®­ЄЁ. Ќ ЇаЁ¬Ґа
| | | | | | | | | ...
^ ®вбо¤ 

| | | | | | | | | ...
^ ў нв® ¬Ґбв®

*/
for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nsymbols; i++)
putchar(symbol);
putchar('\n');
}

void main(){
/* ЋЃљџ‚‹…Ќ€… Џ…ђ…Њ…ЌЌ›• */
int nline; /* ­®¬Ґа бва®ЄЁ */

/* ‚›ЏЋ‹Ќџ…Њ›… ЋЏ…ђЂ’Ћђ› („…‰‘’‚€џ) */
for(nline=0; nline < LINES; nline++){

if((nline % 2) == 0) /* зҐв­®Ґ ? */
drawOneLine(LINES - nline - 1, nline*2 + 1, '+', 1, nline);
else drawOneLine(LINES - nline - 1, nline*2 + 1, '*', 9, nline);
}

/* Ђ Ї®зҐ¬г Ё¬Ґ­­® 1 Ё«Ё Ё¬Ґ­­® 9 ?
* Ђ ўбҐ зв® Ї®Ї «®, «Ёим Ўл ­Ґ 0.
* Њ®¦­® 3, 333, 666, -13445, ЁвЇ
*
* ‚®Їа®б: зв® Ўг¤Ґв, Ґб«Ё вгв ­ ЇЁб вм 0 ?
*/
}
09.c

/* ‘«Ґ¤гой п § ¤ з  Ўг¤Ґв Є б вмбп в®Ј®,
зв®Ўл Є ¦¤ п бва®Є  ваҐгЈ®«м­ЁЄ  ЇҐз в « бм
ў ўЁ¤Ґ:
*+*+*+*.....*+*

’гв ­ ¬ 㦥 ЇаЁ¤Ґвбп ¬®¤ЁдЁжЁа®ў вм дг­ЄжЁо аЁб®ў ­Ёп бва®ЄЁ.
*/

#include

int LINES = 25; /* ўбҐЈ® бва®Є. */

void drawOneLine(int nspaces, int nsymbols){
int i;

for(i=0; i < nspaces; i++)
putchar(' ');

/* ў жЁЄ«Ґ ¬л Ўг¤Ґ¬ Їа®ўҐапвм ­  зҐв­®бвм ЌЋЊ…ђ
ЇҐз в Ґ¬®Ј® бЁ¬ў®« .
*/
for(i=0; i < nsymbols; i++){
if((i % 2) == 0)
putchar('*');
else putchar('+');
}
putchar('\n');
}

void main(){
int nline; /* ­®¬Ґа бва®ЄЁ */

for(nline=0; nline < LINES; nline++) {
drawOneLine(LINES - nline - 1, nline*2 + 1);
}
}
10.c

/* ‡ ¤ з  ­ аЁб®ў вм ђЋЊЃ:
*
***
*****
***
*
*/

#include

int LINES = 10; /* ўбҐЈ® бва®Є ў Ї®«®ўЁ­Ґ ஬Ў . */

void drawOneLine(int nspaces, int nsymbols){
int i;

for(i=0; i < nspaces; i++)
putchar(' ');

for(i=0; i < nsymbols; i++)
putchar('+');
putchar('\n');
}

void main(){
int nline; /* ­®¬Ґа бва®ЄЁ */

for(nline=0; nline < LINES; nline++)
drawOneLine(LINES - nline - 1, nline*2 + 1);

/* Њл ­ аЁб®ў «Ё ваҐгЈ®«м­ЁЄ.
’ҐЇҐам ­ ¬ ­г¦Ґ­ ЇҐаҐўҐа­гвл© ваҐгЈ®«м­ЁЄ.
ЏЁиҐ¬ жЁЄ« Ї® гЎлў ­Ёо Ё­¤ҐЄб .
‘ ¤ ­­®Ј® ¬Ґбв  ­®¬Ґа  бва®Є ®вбзЁвлў овбп ў ®Ўа в­®¬ Ї®ап¤ЄҐ:
®в LINES-2 ¤® 0
*/

for(nline=LINES-2; nline >= 0; nline--)
drawOneLine(LINES - nline - 1, nline*2 + 1);
}
11.c

/* Ђ ⥯Ґам аЁб㥬 ஬Ў, ЁбЇ®«м§гп ¬ вҐ¬ вЁзҐбЄЁҐ д®а¬г«л. */

#include

void draw(int nspaces, int nstars, char symbol){
int i;

for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nstars; i++)
putchar(symbol);
putchar('\n');
}

void main(){
int LINES = 21;
int MIDDLELINE = LINES/2 + 1; /* бҐаҐ¤Ё­  ஬Ў  */
int nline;

for(nline=0; nline < MIDDLELINE; nline++)
draw(MIDDLELINE - nline -1, nline*2+1, 'A');

/* “ б«Ґ¤го饣® жЁЄ«  for() ­Ґв Ё­ЁжЁ «Ё§ жЁЁ
­ з «м­®Ј® §­ зҐ­Ёп Ё­¤ҐЄб .
Ќ з «м­®Ґ nline ­ б«Ґ¤гҐвбп Ё§ ЇаҐ¤л¤г饣® жЁЄ« ,
в ЄЁ¬, Є ЄЁ¬ ®­® ®бв «®бм Ї®б«Ґ ҐЈ® ®Є®­з ­Ёп, в® Ґбвм
а ў­л¬ MIDDLELINE.
*/

for( ; nline < LINES; nline++)
draw(nline - MIDDLELINE + 1, (LINES - 1 - nline) * 2 + 1, 'V');
}
* 12_ARRAYS.txt *

ЊЂ‘‘€‚›

Њ ббЁў - нв® ­ҐбЄ®«мЄ® Їа®­г¬Ґа®ў ­­ле ЇҐаҐ¬Ґ­­ле,
®ЎкҐ¤Ё­Ґ­­ле ®ЎйЁ¬ Ё¬Ґ­Ґ¬.
‚ᥠЇҐаҐ¬Ґ­­лҐ Ё¬Ґов Ћ„€Ќ € ’Ћ’ †… ’€Џ.

ђ бᬮваЁ¬ ЏЋ‹Љ“ б N пйЁЄ ¬Ё,
Їгбвм Ё¬п Ї®«ЄЁ - var.
’®Ј¤  Є ¦¦¤л© пйЁЄ-п祩Є  Ё¬ҐҐв Ё¬п
var[0]
var[1]
...
var[N-1]

Ќг¬Ґа жЁп Ё¤Ґв б Ќ“‹џ.

--------
/ var /
/ /
------------------------------------------- ------------------
| | | | | |
| | | | .... ... | |
| | | | | |
------------------------------------------- ------------------
/ var[0] / / var[1] / / var[2] / / var[N-1] /
--------- --------- --------- -----------

Њ ббЁў ®Ўкпў«пҐвбп в Є:

int var[N];

§¤Ґбм N - ҐЈ® а §¬Ґа, зЁб«® п祥Є.

ќв® ®ЇЁб ­ЁҐ Є Є Ўл ®Ўкпў«пҐв N ЇҐаҐ¬Ґ­­ле вЁЇ  int б Ё¬Ґ­ ¬Ё
var[0] ... var[N-1];

‚ ®ЇҐа в®а е ¤«п ®Ўа йҐ­Ёп Є n-®¬г пйЁзЄг (Ј¤Ґ 0 <= n < N)
ЁбЇ®«м§гҐвбп Ё¬п пйЁЄ 

var[n]

Ј¤Ґ n - 楫®Ґ §­ зҐ­ЁҐ (Ё«Ё §­ зҐ­ЁҐ 楫®© ЇҐаҐ¬Ґ­­®©,
Ё«Ё 楫®зЁб«Ґ­­®Ј® ўла ¦Ґ­Ёп), "Ё­¤ҐЄб ў ¬ ббЁўҐ".
ќв  ®ЇҐа жЁп [] ­ §лў Ґвбп "Ё­¤ҐЄб жЁп ¬ ббЁў ".
€­¤ҐЄб жЁп - Ґбвм ‚›ЃЋђ ®¤­®Ј® Ё§ N пйЁЄ®ў ЇаЁ Ї®¬®йЁ гЄ § ­Ёп 楫®Ј® ­®¬Ґа .
var - ¬ ббЁў (N п祥Є)
n - ўла ¦Ґ­ЁҐ (д®а¬г« ), ўл¤ ой п 楫®Ґ §­ зҐ­ЁҐ ў Ё­вҐаў «Ґ 0..N-1
var[n] - ў§пв ®¤Ё­ Ё§ н«Ґ¬Ґ­в®ў ¬ ббЁў . Ћ¤Ё­ Ё§ ўбҐе.
n - ­®¬Ґа пйЁЄ  - ­ §лў Ґвбп ҐйҐ Ё "Ё­¤ҐЄб®¬" нв®© ЇҐаҐ¬Ґ­­®© ў ¬ ббЁўҐ.

ЏаЁ¬Ґа:

int var[5]; /* 1 */

var[0] = 2; /* 2 */
var[1] = 3 + var[0]; /* 3 */
var[2] = var[0] * var[1]; /* 4 */
var[3] = (var[0] + 4) * var[1]; /* 5 */

printf("var ваҐвмҐ Ґбвм %d\n", var[3]);

‚ 室Ґ нв®© Їа®Ја ¬¬л н«Ґ¬Ґ­вл ¬ ббЁў  ¬Ґ­повбп в ЄЁ¬ ®Ўа §®¬:

var[0] var[1] var[2] var[3] var[4]
------------------------------------------------
/* 1 */ ¬гб®а ¬гб®а ¬гб®а ¬гб®а ¬гб®а
/* 2 */ 2 ¬гб®а ¬гб®а ¬гб®а ¬гб®а
/* 3 */ 2 5 ¬гб®а ¬гб®а ¬гб®а
/* 4 */ 2 5 10 ¬гб®а ¬гб®а
/* 5 */ 2 5 10 30 ¬гб®а

Љ Є ўЁ¤Ё¬, Є ¦¤л© ®ЇҐа в®а Ё§¬Ґ­пҐв «Ёим Ћ„Ќ“ п祩Єг ¬ ббЁў  §  а §.

Њ ббЁў - ­ Ў®а ЇҐаҐ¬Ґ­­ле, Є®в®алҐ ­Ґ €Њ…ЌЋ‚ЂЌ› а §­л¬Ё Ё¬Ґ­ ¬Ё,
ўа®¤Ґ var0, var1, var2, ...
  ЏђЋЌ“Њ…ђЋ‚ЂЌ› Ї®¤ ®¤­Ё¬ Ё¬Ґ­Ґ¬:
var[0], var[1], var[2], ...

€­¤ҐЄб - з бвм €Њ…Ќ€ Џ…ђ…Њ…ЌЌЋ‰.

Ќ  б ¬®¬ ¤Ґ«Ґ Ё­¤ҐЄб жЁп - нв®
1) ўлЎ®а н«Ґ¬Ґ­в  ў ¬ ббЁўҐ
2) бЇа ў  ®в ЇаЁбў Ёў ­Ё© Ё ў ўла ¦Ґ­Ёпе - ҐйҐ Ё ࠧ묥­®ў ­ЁҐ,
в® Ґбвм ў§пвЁҐ ў¬Ґбв® Ё¬Ґ­Ё ЇҐаҐ¬Ґ­­®© - §­ зҐ­Ёп, ў ­Ґ© еа ­п饣®бп.
---------------------------------------------------------------------------

…б«Ё ў ЇҐаҐ¬Ґ­­го ­Ґ Ўл«® § ­ҐбҐ­® §­ зҐ­ЁҐ,
  ¬л ЁбЇ®«м§гҐ¬ нвг ЇҐаҐ¬Ґ­­го,
в® ў ­Ґ© «Ґ¦Ёв Њ“‘Ћђ («оЎ®Ґ, ­ҐЇаҐ¤бЄ §гҐ¬®Ґ §­ зҐ­ЁҐ).

printf("var4 Ґбвм %d\n", var[4]);

­ ЇҐз в Ґв ўбҐ зв® гЈ®¤­®.

Џ®н⮬㠯ҐаҐ¬Ґ­­лҐ ­ ¤® ўбҐЈ¤  Ё­ЁжЁ «Ё§Ёа®ў вм
(¤ ў вм Ё¬ ­ з «м­®Ґ §­ зҐ­ЁҐ).

ѓ«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ  ўв®¬ вЁзҐбЄЁ Ё­ЁжЁ «Ё§Ёаговбп ­г«Ґ¬,
Ґб«Ё ¬л ­Ґ § ¤ «Ё Ё­ зҐ.

‹®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ ­Ґ Ё­ЁжЁ «Ё§Ёаговбп  ўв®¬ вЁзҐбЄЁ, Ё ᮤҐа¦ в Њ“‘Ћђ.
---------------------------------------------------------------------------

Њ ббЁўл Ќ…‹њ‡џ ЇаЁбў Ёў вм 楫ЁЄ®¬, п§лЄ ‘Ё нв®Ј® ­Ґ 㬥Ґв.

int a[5];
int b[5];

a = b; /* ®иЁЎЄ  */

’ Є¦Ґ ­Ґ«м§п ЇаЁбў®Ёвм §­ зҐ­ЁҐ бࠧ㠢ᥬ н«Ґ¬Ґ­в ¬ (п祩Є ¬) ¬ ббЁў :

a = 0; /* ®иЁЎЄ  */

­Ґ ¤Ґ« Ґв в®Ј®, зв® ­ ¬Ё ®¦Ё¤ «®бм,   пў«пҐвбп ®иЁЎЄ®©.
„«п ®Ў­г«Ґ­Ёп ўбҐе п祥Є б«Ґ¤гҐв ЁбЇ®«м§®ў вм жЁЄ«:

int i;

for(i=0; i < 5; i++) /* ¤«п Є ¦¤®Ј® i ЇаЁбў®Ёвм a[i] = 0; */
a[i] = 0;

---------------------------------------------------------------------------

‘‚џ‡њ ЊЂ‘‘€‚Ћ‚ € –€Љ‹Ћ‚
=======================
‚б«Ґ¤бвўЁҐ нв®Ј® ¬ ббЁўл ЇаЁе®¤Ёвбп Є®ЇЁа®ў вм (Ё Ё­ЁжЁ «Ё§Ёа®ў вм)
Ї®н«Ґ¬Ґ­в­®, ў жЁЄ«Ґ ЇҐаҐЎЁа п ўбҐ (Ё«Ё з бвм) п祩ЄЁ ¬ ббЁў .

int i;

for(i=0; i < 5; i++)
a[i] = b[i];

‚ ¤ ­­®¬ б«гз Ґ Ё­¤ҐЄб жЁЄ«  б«г¦Ёв в Є¦Ґ Ё Ё­¤ҐЄб®¬ ў ¬ ббЁўҐ.

€­¤ҐЄбл ў ¬ ббЁўҐ Ё¤гв б Ќ“‹џ.

ЏаЁ¬Ґа Ё­ЁжЁ «Ё§ жЁЁ:

int index, array[5];

for(index=0; index < 5; index++)
array[index] = index * 2 + 1;

Ё«Ё

int index, array[5];

index = 0;
while(index < 5){
array[index] = index * 2 + 1;
index++;
}

/* ‚ ¬ ббЁўҐ Ўг¤Ґв: { 1, 3, 5, 7, 9 } */

€Ќ„…Љ‘
¤«п ¬ ббЁў®ў -
­®¬Ґа "пйЁЄ /п祩ЄЁ" ў ¬ ббЁўҐ.

¤«п жЁЄ«®ў -
­®¬Ґа Ї®ўв®аҐ­Ёп жЁЄ« , бзҐвзЁЄ.
Њл ¤®«¦­л Ё§¬Ґ­пвм ҐЈ® ‘ЂЊ€.

ЋЎлз­® ¬ ббЁўл Ё жЁЄ«л б®ў¬Ґй овбп в Є:
Ё­¤ҐЄб жЁЄ«  Ґбвм Ё­¤ҐЄб ў ¬ ббЁўҐ;
в® Ґбвм Ё­¤ҐЄб жЁЄ«  ЁбЇ®«м§гҐвбп ¤«п ЇҐаҐЎ®а  ўбҐе
н«Ґ¬Ґ­в®ў ¬ ббЁў :

int a[N], i;

for(i=0; i < N; i++)
...a[i]...
---------------------------------------------------------------------------

ЏаЁ¬Ґал:

int a[5];

a[0] = 17;
a[0] += 4;
a[0]++;
---------------------------------------------------------------------------

ЏаЁ¬Ґа: зЁб«  ”ЁЎ®­ ззЁ.
‡ ¤ овбп ¬ вҐ¬ вЁзҐбЄЁ¬Ё д®а¬г« ¬Ё:

f[1] = 1
f[2] = 1
f[n+2] = f[n+1] + f[n]

‚®в Їа®Ја ¬¬ :
---------------------------------------------------------------------------

#include /* ¬ ЈЁзҐбЄ п бва®Є  */
#define N 20 /* бЄ®«мЄ® ЇҐаўле зЁбҐ« Ї®бзЁв вм */

void main(){
int fibs[N], index;

fibs[0] = 1; /* Ё­¤ҐЄбл ®вбзЁвлў овбп б ­г«п!!! */
fibs[1] = 1;

/* ’гв Ї®Є § ­®, зв® Ё­¤ҐЄб н«Ґ¬Ґ­в  ¬ ббЁў  ¬®¦Ґв ўлзЁб«пвмбп */

for(index=2; index < N; index++)
fibs[index] = fibs[index-1] + fibs[index-2];

/* ђ бЇҐз вЄ  ў ®Ўа в­®¬ Ї®ап¤ЄҐ */
for(index = N-1; index >= 0; index--)
printf("%d-®Ґ зЁб«® ”ЁЎ®­ ззЁ Ґбвм %d\n",
index+1, fibs[index]);
}

‡¤Ґбм ¬л ўЁ¤Ё¬ ­®ўл© ¤«п ­ б ®ЇҐа в®а #define
Ћ­ § ¤ Ґв ⥪бвг «м­го ‡ЂЊ…Ќ“ б«®ў  N ­  б«®ў® 20,
ў ¤ ­­®¬ б«гз Ґ Їа®бв® пў«ппбм нЄўЁў «Ґ­в®¬

const int N = 20;

Љ ­Ґбз бвмо а §¬Ґа ¬ ббЁў  ­Ґ ¬®¦Ґв Ўлвм § ¤ ­ ЇаЁ Ї®¬®йЁ ЇҐаҐ¬Ґ­­®©,
  ў®в ЇаЁ Ї®¬®йЁ Ё¬Ґ­Ё, ®ЇаҐ¤Ґ«Ґ­­®Ј® ў #define - ¬®¦Ґв.

‘’ђЋЉ€

‘ва®ЄЁ Ґбвм ¬ ббЁўл Ѓ“Љ‚ - вЁЇ  char,
®Є ­зЁў ойЁҐбп бЇҐжбЁ¬ў®«®¬ \0

char string[20];

string[0] = 'Џ';
string[1] = 'а';
string[2] = 'Ё';
string[3] = 'ў';
string[4] = 'Ґ';
string[5] = 'в';
string[6] = '\0';

printf("%s\n", string);

%s - д®а¬ в ¤«п ЇҐз вЁ ‘’ђЋЉ.
ЌЁЄ ЄЁҐ ¤агЈЁҐ ¬ ббЁўл ­Ґ ¬®Јгв Ўлвм ­ ЇҐз в ­л
楫ЁЄ®¬ ®¤­Ё¬ ®ЇҐа в®а®¬.

char string[20];

string[0] = 'Џ';
string[1] = 'а';
string[2] = 'Ё';
string[3] = 'ў';
string[4] = 'Ґ';
string[5] = 'в';
string[6] = '\n'; /* ЏҐаҐў®¤ бва®ЄЁ - ⮦Ґ ЎгЄў  */
string[7] = '\0';

printf("%s", string);

Ё«Ё ¤ ¦Ґ Їа®бв®

printf(string);

’ ЄЁҐ ¬ ббЁўл ¬®¦­® § ЇЁб вм ў ўЁ¤Ґ бва®ЄЁ ЎгЄў ў ""

char string[20] = "ЏаЁўҐв\n";

Ћбв ўиЁҐбп ­ҐЁбЇ®«м§®ў ­­л¬Ё бЁ¬ў®«л ¬ ббЁў  ®в string[8] ¤® string[19]
ᮤҐа¦ в Њ“‘Ћђ.

ЏЋ—…Њ“ „‹џ ‘’ђЋЉ €‡ЋЃђ…‹€ ‘€Њ‚Ћ‹ "Џђ€‡ЌЂЉ ЉЋЌ–Ђ"?
=================================================
‘ва®Є  - нв® —Ђ‘’њ ¬ ббЁў  ЎгЄў.
‚ а §­®Ґ ўаҐ¬п зЁб«® ЎгЄў ў бва®ЄҐ ¬®¦Ґв Ўлвм а §«Ёз­л¬,
«Ёим Ўл ­Ґ ЇаҐўли «® а §¬Ґа ¬ ббЁў  (в®Ј¤  б«гзЁвбп бЎ®© Їа®Ја ¬¬л).
‡­ зЁв, б«Ґ¤гҐв Ј¤Ґ-в® еа ­Ёвм ⥪гйго ¤«Ё­г бва®ЄЁ (зЁб«® ЁбЇ®«м§®ў ­­ле
бЁ¬ў®«®ў). …бвм ваЁ аҐиҐ­Ёп:
(1) ‚ ®в¤Ґ«м­®© ЇҐаҐ¬Ґ­­®©. …Ґ б«Ґ¤гҐв ЇҐаҐ¤ ў вм ў® ўбҐ
дг­ЄжЁЁ ®Ўа Ў®вЄЁ ¤ ­­®© бва®ЄЁ (ЇаЁзҐ¬ ®­  ¬®¦Ґв Ё§¬Ґ­пвмбп).

char str[32]; /* ¬ ббЁў ¤«п бва®ЄЁ */
int slen; /* Ўа вм ЇҐаўлҐ slen ЎгЄў ў н⮬ ¬ ббЁўҐ */
...
func(str, &slen); /* „‚Ђ  аЈг¬Ґ­в  ¤«п ЇҐаҐ¤ зЁ Ћ„ЌЋ‰ бва®ЄЁ */
...

ќв®в Ї®¤е®¤ а Ў®в®бЇ®б®ЎҐ­, ­® бва®Є  а §ЎЁў Ґвбп ­  ¤ў 
®ЎкҐЄв : б ¬ ¬ ббЁў Ё ЇҐаҐ¬Ґ­­го ¤«п ҐЈ® ¤«Ё­л. ЌҐг¤®Ў­®.

(2) •а ­Ёвм ⥪гйго ¤«Ё­г ў н«Ґ¬Ґ­вҐ str[0],
  ЎгЄўл - ў str[1] ... Ёв¤.
Џ«®е® ⥬, зв® ў str[0] ¬®¦­® еа ­Ёвм «Ёим зЁб«  ®в 0 ¤® 255,
Ё Ґб«Ё бва®Є  ¤«Ё­­ҐҐ - в® в Є®© Ї®¤е®¤ ­ҐЇаЁ¬Ґ­Ё¬.

(3) ЌҐ еа ­Ёвм ¤«Ё­г Ќ€ѓ„…,   ўўҐбвЁ бЁ¬ў®«-ЇаЁ§­ Є Є®­ж  бва®ЄЁ.
’ҐЇҐам ў

func(str); /* Ћ„€Ќ  аЈг¬Ґ­в - б ¬ ¬ ббЁў */

ЇҐаҐ¤ Ґвбп в®«мЄ® б ¬ ¬ ббЁў,   ҐЈ® ⥪гй п ¤«Ё­  ¬®¦Ґв Ўлвм
ЇаЁ ­г¦¤Ґ ўлзЁб«Ґ­  ЇаЁ Ї®¬®йЁ ­ҐЄ®Ґ© дг­ЄжЁЁ, ўа®¤Ґ в Є®©:

int strlen(char s[]){ /* дг­ЄжЁп ®в ¬ ббЁў  ЎгЄў */
int counter = 0; /* бзҐвзЁЄ Ё ®¤­®ўаҐ¬Ґ­­® Ё­¤ҐЄб */

while(s[counter] != '\0') /* Ї®Є  ­Ґ ўбваҐвЁ«бп ЇаЁ§­ Є Є®­ж  ⥪бв  */
counter++; /* Ї®бзЁв вм бЁ¬ў®« */
return counter; /* бЄ®«мЄ® бЁ¬ў®«®ў, ®в«Ёз­ле ®в '\0' */
}

’гв ­ЁЄ ЄЁе ®Ја ­ЁзҐ­Ё© ­Ґв. €¬Ґ­­® нв®в Ї®¤е®¤ Ё Ўл« Ё§Ўа ­
ў п§лЄҐ ‘Ё, е®вп ў ЇаЁ­жЁЇҐ ¬®¦­® б ¬®¬г Ї®«м§®ў вмбп Ё ¤агЈЁ¬Ё.
Ќ  б ¬®¬ ¤Ґ«Ґ ў п§лЄҐ Ґбвм в Є п ‘’ЂЌ„Ђђ’ЌЂџ дг­ЄжЁп strlen(s)
(ў ¬ ­Ґ ­ ¤® ЇЁб вм ҐҐ б ¬®¬г, ҐҐ 㦥 ­ ЇЁб «Ё §  ў б).
---------------------------------------------------------------------------

€Ќ€–€Ђ‹€‡Ђ–€џ ѓ‹ЋЃЂ‹њЌЋѓЋ ЊЂ‘‘€‚Ђ
=================================
Њ ббЁў, § ¤ ­­л© ў­Ґ Є ЄЁе-«ЁЎ® дг­ЄжЁ©, ¬®¦­® Їа®Ё­ЁжЁ «Ё§Ёа®ў вм
Є®­бв ­в­л¬Ё ­ з «м­л¬Ё §­ зҐ­Ёп¬Ё:

int array[5] = { 12, 23, 34, 45, 56 };

char string[7] = { 'Џ', 'а', 'Ё', 'ў', 'Ґ', 'в', '\0' };

…б«Ё а §¬Ґа ¬ ббЁў  гЄ § ­ ЃЋ‹њ…, 祬 ¬л ЇҐаҐзЁб«Ё¬ н«Ґ¬Ґ­в®ў,
в® ®бв «м­лҐ н«Ґ¬Ґ­вл § Ї®«­пвбп ­г«п¬Ё (¤«п int) Ё«Ё '\0' ¤«п char.

int array[5] = { 12, 23, 34 };

…б«Ё ¬л ЇҐаҐзЁб«Ё¬ Ў®«миҐ н«Ґ¬Ґ­в®ў, 祬 Ї®§ў®«пҐв а §¬Ґа ¬ ббЁў  -
нв® Ўг¤Ґв ®иЁЎЄ®©.

int a[5] = { 177, 255, 133 };

ЋЇҐа жЁп Ё­¤ҐЄб жЁЁ ¬ ббЁў  a[] ¤ Ґв:

ЇаЁ n §­ зҐ­ЁҐ ўла ¦Ґ­Ёп a[n] Ґбвм
---------------------------------------------------------------------------

-1 ­Ґ ®ЇаҐ¤Ґ«Ґ­® (®иЁЎЄ : "Ё­¤ҐЄб §  Ја ­ЁжҐ© ¬ ббЁў ")
0 177
1 255
2 133
3 0
4 0
5 ­Ґ ®ЇаҐ¤Ґ«Ґ­® (®иЁЎЄ )
* 13_FUNCS.txt *

ЉЂЉ ЏђЋ€‘•Ћ„€’ ‚›‡Ћ‚ ”“ЌЉ–€€
============================

Џгбвм г ­ б ®ЇЁб ­  дг­ЄжЁп, ў®§ўа й ой п 楫®Ґ §­ зҐ­ЁҐ.

/* ЋЏђ…„…‹…Ќ€… ”“ЌЉ–€€ func(). */
/* ѓ¤Ґ func - ҐҐ Ё¬п. Ќ §ў вм ¬л ҐҐ ¬®¦Ґ¬ Є Є ­ ¬ гЈ®¤­®. */

int func(int a, int b, int c){
int x, y;

...
x = a + 7;
...
b = b + 4;
...

return(­ҐЄ®Ґ_§­ зҐ­ЁҐ);
}

‡¤Ґбм
a, b, c -  аЈг¬Ґ­вл дг­ЄжЁЁ (Ї а ¬Ґвал)
x, y - «®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ

’®зЄ  ўл§®ў  - ­ е®¤Ёвбп ў­гваЁ Є Є®©-в® ¤агЈ®©
дг­ЄжЁЁ, ­ ЇаЁ¬Ґа дг­ЄжЁЁ main()

main(){

int zz, var;
...
var = 17;
zz = func(33, 77, var + 3) + 44;
...
}

Љ®Ј¤  ўлЇ®«­Ґ­ЁҐ Їа®Ја ¬¬л ¤®е®¤Ёв ¤® бва®ЄЁ

zz = func(33, 77, var + 3) + 44;

1) Џа®Ёб室Ёв ‚›‡Ћ‚ ”“ЌЉ–€€ func()

(a) ќв®в Їг­Єв ¬л гўЁ¤Ё¬ ­Ё¦Ґ.

(b) ‘®§¤ овбп ЇҐаҐ¬Ґ­­лҐ б Ё¬Ґ­ ¬Ё a, b, c, x, y;

(c) ЏҐаҐ¬Ґ­­л¬- аЈг¬Ґ­в ¬ ЇаЁбў Ёў овбп ­ з «м­лҐ §­ зҐ­Ёп,
Є®в®алҐ ЎҐагвбп Ё§ в®зЄЁ ўл§®ў .
‚ в®зЄҐ ўл§®ў  ЇҐаҐзЁб«Ґ­ бЇЁб®Є (зҐаҐ§ § Їпвго) ўла ¦Ґ­Ё© (д®а¬г«):

func(ўла ¦Ґ­ЁҐ1, ўла ¦Ґ­ЁҐ2, ўла ¦Ґ­ЁҐ3)

‚лзЁб«Ґ­­лҐ §­ зҐ­Ёп нвЁе ўла ¦Ґ­Ё© ᮮ⢥вб⢥­­® Ўг¤гв ЇаЁбў®Ґ­л
1-®¬г, 2-®¬г Ё 3-Ґ¬г  аЈг¬Ґ­в ¬ (Ї а ¬Ґва ¬) Ё§ ®ЇаҐ¤Ґ«Ґ­Ёп дг­ЄжЁЁ:

int func(a, b, c){ /* a = ­®¬Ґа 1, b = 2, c = 3 */

ЏҐаўл© Ї а ¬Ґва:

a = 33;

‚в®а®© Ї а ¬Ґва:

b = 77;

’аҐвЁ© Ї а ¬Ґва:

c = var + 3;

в® Ґбвм, ўлзЁб«пп,

c = 20;

‹®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ x Ё y ᮤҐа¦ в ­Ґ®ЇаҐ¤Ґ«Ґ­­лҐ §­ зҐ­Ёп,
в® Ґбвм ¬гб®а (¬л ­Ґ ¬®¦Ґ¬ ЇаҐ¤бЄ § вм Ёе §­ зҐ­Ёп,
Ї®Є  ­Ґ ЇаЁбў®Ё¬ Ё¬ пў­л¬ ®Ўа §®¬ Є Є®Ґ-«ЁЎ® §­ зҐ­ЁҐ б ¬Ё).

2) ‚лЇ®«­пҐвбп ’…‹Ћ дг­ЄжЁЁ, в® Ґбвм ўлзЁб«Ґ­Ёп, § ЇЁб ­­лҐ ў­гваЁ { ... }
ў ®ЇаҐ¤Ґ«Ґ­ЁЁ дг­ЄжЁЁ. Ќ ЇаЁ¬Ґа:

x = a + 7;

€ Ї а ¬Ґвал, Ё «®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ - нв® Џ…ђ…Њ…ЌЌ›…,
в® Ґбвм Ёе ¬®¦­® Ё§¬Ґ­пвм.

b = b + 4;

ЏаЁ н⮬ ­ЁЄ ЄЁҐ ЇҐаҐ¬Ґ­­лҐ ‚Ќ… нв®© дг­ЄжЁЁ ­Ґ Ё§¬Ґ­повбп.
(ЋЎ н⮬ ҐйҐ а § Ї®§¦Ґ).

3) Џа®Ё§ў®¤Ёвбп ‚Ћ‡‚ђЂ’ Ё§ дг­ЄжЁЁ.

...
return(­ҐЄ®Ґ_§­ зҐ­ЁҐ);
}

Ќ ЇаЁ¬Ґа, нв® ¬®¦Ґв Ўлвм

...
return(a + 2 * x);
}

ђ бᬮваЁ¬, зв® ЇаЁ н⮬ Їа®Ёб室Ёв ў в®зЄҐ ўл§®ў :

zz = func(33, 77, var + 3) + 44;

(1) ‚лзҐаЄЁў Ґ¬ func(.....)

zz = XXXXXXX + 44;

(2) ‚лзЁб«пҐ¬ §­ зҐ­ЁҐ "­ҐЄ®Ґ_§­ зҐ­ЁҐ" ў ®ЇҐа в®аҐ return,
Ё ЎҐаҐ¬ ЉЋЏ€ћ нв®Ј® §­ зҐ­Ёп.
Џгбвм ЇаЁ ўлзЁб«Ґ­ЁЁ в ¬ Ї®«гзЁ«®бм 128.

(3) Џ®¤бв ў«пҐ¬ нв® §­ зҐ­ЁҐ ­  ¬Ґбв® ўлзҐаЄ­гв®Ј® func(.....)
“ ­ б Ї®«гз Ґвбп

zz = 128 + 44;

(4) Ђ‚’ЋЊЂ’€—…‘Љ€ “Ќ€—’Ћ†Ђћ’‘џ «®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ Ё  аЈг¬Ґ­вл дг­ЄжЁЁ:

a - гЎЁв®
b - гЎЁв®
c - гЎЁв®
x - гЎЁв®
y - гЎЁв®

’ ЄЁе ЇҐаҐ¬Ґ­­ле (Ё Ёе §­ зҐ­Ё©) Ў®«миҐ ­Ґв ў ЇаЁа®¤Ґ.

(5) Џг­Єв, Є®в®ал© ¬л ®Ўбг¤Ё¬ Ї®§¦Ґ.

(6) Џа®¤®«¦ Ґ¬ ўлзЁб«Ґ­ЁҐ:

zz = 128 + 44;

‚лзЁб«пҐвбп ў

zz = 172; /* ®ЇҐа в®а ЇаЁбў Ёў ­Ёп */

---------------------------------------------------------------------------

int func1(int x){
printf("func1: x=%d\n", x); /* 1 */
x = 77;
printf("func1: x=%d\n", x); /* 2 */
return x;
}

void main(){
int var, y;

var = 111;
y = func1(var); /* @ */

printf("main: var=%d\n", var); /* 3 */
}

‚ ¤ ­­®¬ б«гз Ґ ў в®зЄҐ @ ¬л ЇҐаҐ¤ Ґ¬ ў дг­ЄжЁо func1()
‡ЌЂ—…Ќ€… ЇҐаҐ¬Ґ­­®© var, а ў­®Ґ 111.
ќв® §­ зЁв, зв® ЇаЁ ўл§®ўҐ дг­ЄжЁЁ Ўг¤Ґв ᮧ¤ ­  ЇҐаҐ¬Ґ­­ п x
Ё Ґ© Ўг¤Ґв ЇаЁбў®Ґ­® ­ з «м­®Ґ §­ зҐ­ЁҐ 111

x = 111;

Џ®н⮬㠯Ґаўл© ®ЇҐа в®а printf() ­ ЇҐз в Ґв 111.

‡ вҐ¬ ¬л Ё§¬Ґ­пҐ¬ §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© x ­  77.
Њл ¬Ґ­пҐ¬ ЇҐаҐ¬Ґ­­го x, ­® ­Ґ ЇҐаҐ¬Ґ­­го var !!!
€бЇ®«м§®ў ў ‡ЌЂ—…Ќ€… (ҐЈ® Є®ЇЁо) Ё§ ЇҐаҐ¬Ґ­­®© var ¤«п x,
¬л ® ЇҐаҐ¬Ґ­­®© var § Ўл«Ё - ®­  ­ б ­Ґ Є б Ґвбп (  ¬л - ҐҐ).

Џ®н⮬㠢в®а®© ®ЇҐа в®а printf() ­ ЇҐз в Ґв 77.
‚ ЇҐаҐ¬Ґ­­®© ¦Ґ var ®бв «®бм §­ зҐ­ЁҐ 111,
зв® Ё Ї®¤вўҐа¤Ёв ­ ¬ ваҐвЁ© ®ЇҐа в®а printf,
Є®в®ал© ­ ЇҐз в Ґв 111.

---------------------------------------------------------------------------

‚ђ…Њ…ЌЌЋ… ‘ЋЉђ›’€… Џ…ђ…Њ…ЌЌ›•
=============================

int func1(int x){ /* f.1 */
printf("func1: x=%d\n", x); /* f.2 */
x = 77; /* f.3 */
printf("func1: x=%d\n", x); /* f.4 */
return x; /* f.5 */
}

void main(){
int x, y; /* 1 */

x = 111; /* 2 */
y = func1(x); /* 3 */

printf("main: x=%d y=%d\n", x, y); /* 4 */
}

Ђ ⥯Ґам ¬л Ё ЇҐаҐ¬Ґ­­го ў­гваЁ main(), Ё  аЈг¬Ґ­в дг­ЄжЁЁ
func1() ­ §ў «Ё ®¤­Ё¬ Ё ⥬ ¦Ґ Ё¬Ґ­Ґ¬. —в® Ўг¤Ґв?

Ѓг¤Ґв в® ¦Ґ б ¬®Ґ, зв® ў ЇаҐ¤л¤г饬 ЇаЁ¬ҐаҐ.

‚ ¬®¬Ґ­в ўл§®ў  дг­ЄжЁЁ func1() Ўг¤Ґв ᮧ¤ ­  ЌЋ‚Ђџ ЇҐаҐ¬Ґ­­ п
б Ё¬Ґ­Ґ¬ x,   бв а п (ЇаҐ¦­пп) ЇҐаҐ¬Ґ­­ п Ё ҐҐ §­ зҐ­ЁҐ Ўг¤гв
‚ђ…Њ…ЌЌЋ ‘Џђџ’ЂЌ› (бЄалвл).

Њ®¦­® Ўл«® Ўл гв®з­Ёвм нвЁ ЇҐаҐ¬Ґ­­лҐ Ё¬Ґ­ ¬Ё дг­ЄжЁ©,
ў Є®в®але ®­Ё ®ЇаҐ¤Ґ«Ґ­л:

main::x

Ё

func1::x

(­® н⮠㦥 Є®­бвагЄжЁЁ Ё§ п§лЄ  ‘Ё++,   ­Ґ ‘Ё).

‚лЇ®«­Ё¬ Їа®Ја ¬¬г Ї® ®ЇҐа в®а ¬:

|/* 1 */ Ћвў®¤пвбп ЇҐаҐ¬Ґ­­лҐ main::x Ё main::y ¤«п 楫ле зЁбҐ«;
|/* 2 */ main::x = 111;
|/* 3 */ ‚л§лў Ґвбп func1(111);
|
+-------+
. |/* f.1 */ Ћвў®¤Ёвбп ЇҐаҐ¬Ґ­­ п func1::x б® §­ зҐ­ЁҐ¬ 111;
. |/* f.2 */ ЏҐз в Ґвбп 111 Ё§ ЇҐаҐ¬Ґ­­®© func1::x;
. |
. |/* f.3 */ func1::x = 77; (нв® ­Ґ main::x,   ¤агЈ п ЇҐаҐ¬Ґ­­ п,
. | ‹ЋЉЂ‹њЌЂџ ¤«п дг­ЄжЁЁ func1.
. | ЏҐаҐ¬Ґ­­го main::x ¬л ᥩз б ­Ґ ўЁ¤Ё¬ -
. | ®­  "§ б«®­Ґ­ " Ё¬Ґ­Ґ¬ ­ иҐ© «®Є «м­®©
. | ЇҐаҐ¬Ґ­­®©.
. | Џ®нв®¬г ¬л ­Ґ ¬®¦Ґ¬ ҐҐ Ё§¬Ґ­Ёвм).
. |
. |/* f.4 */ ЏҐз в Ґв 77 Ё§ func1::x;
. |/* f.5 */ ‚®§ўа й Ґв §­ зҐ­ЁҐ func1::x , в® Ґбвм 77.
. | ЏҐаҐ¬Ґ­­ п func1::x г­Ёз⮦ Ґвбп.
. |
. | ’ҐЇҐам ¬л б­®ў  ў®§ўа й Ґ¬бп ў дг­ЄжЁо main(),
. | Ј¤Ґ Ё¬п x ®Ў®§­ з Ґв ЇҐаҐ¬Ґ­­го main::x

+-------+
|
|/* 3 */ y = 77;
|/* 4 */ ЏҐз в Ґв §­ зҐ­Ёп main::x Ё main::y, в® Ґбвм
| 111 Ё 77.

ќв®в ¬Ґе ­Ё§¬ б®ЄалвЁп Ё¬Ґ­ Ї®§ў®«пҐв ЇЁб вм дг­ЄжЁЁ main() Ё func1()
а §­л¬ Їа®Ја ¬¬Ёбв ¬, Ї®§ў®«пп Ё¬ Ќ… ‡ЂЃЋ’€’њ‘џ ® ⮬, зв®Ўл Ё¬Ґ­ 
«®Є «м­ле ЇҐаҐ¬Ґ­­ле ў дг­ЄжЁпе Ќ… ‘Ћ‚ЏЂ„Ђ‹€. Џгбвм б®ўЇ ¤ ов - е㦥 ­Ґ
Ўг¤Ґв, ¬Ґе ­Ё§¬ гЇапвлў ­Ёп Ё¬Ґ­ а §аҐиЁв Є®­д«ЁЄв.
‡ в® Їа®Ја ¬¬Ёбв ¬®¦Ґв ЁбЇ®«м§®ў вм «оЎ®Ґ Ї®­а ўЁўиҐҐбп Ґ¬г Ё¬п
ў «оЎ®© дг­ЄжЁЁ - е®вп Ўл Ё x, Ё«Ё i.

---------------------------------------------------------------------------

’® ¦Ґ б ¬®Ґ Їа®Ёб室Ёв б «®Є «м­л¬Ё ЇҐаҐ¬Ґ­­л¬Ё,
  ­Ґ б  аЈг¬Ґ­в ¬Ё дг­ЄжЁЁ.

int func1(int arg){ /* «®Є «м­ п ЇҐаҐ¬Ґ­­ п-Ї а ¬Ґва func1::arg */
int x; /* «®Є «м­ п ЇҐаҐ¬Ґ­­ п func1::x */

x = arg;
printf("func1: x=%d\n", x);
x = 77;
printf("func1: x=%d\n", x);
return x;
}

void main(){
int x, y; /* ЇҐаҐ¬Ґ­­лҐ main::x Ё main::y */

x = 111;
y = func1(x);

printf("main: x=%d y=%d\n", x, y);
}

„Ґ©бвўгҐв в®в ¦Ґ б ¬л© ¬Ґе ­Ё§¬ ўаҐ¬Ґ­­®Ј® б®ЄалвЁп Ё¬Ґ­Ё x.
‚®®ЎйҐ ¦Ґ,  аЈг¬Ґ­вл дг­ЄжЁЁ Ё ҐҐ «®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ
®в«Ёз овбп в®«мЄ® ®¤­Ё¬:
 аЈг¬Ґ­в ¬  ўв®¬ вЁзҐбЄЁ ЇаЁбў Ёў овбп
­ з «м­лҐ §­ зҐ­Ёп, а ў­лҐ §­ зҐ­Ёп¬ ᮮ⢥вбвўгойЁе ўла ¦Ґ­Ё©
ў бЇЁбЄҐ

Ё¬п_дг­ЄжЁЁ(..., ..., ....)
 аЈ1  аЈ2  аЈ3

ў ¬Ґб⥠ўл§®ў  дг­ЄжЁЁ.

’® Ґбвм

ЋЏ€‘ЂЌ€… ”“ЌЉ–€€:

int f(int  аЈ1, int  аЈ2, int  аЈ3){
int ЇҐаҐ¬1, ЇҐаҐ¬2;
...
/* Їа®¤®«¦Ґ­ЁҐ */
}

‚›‡Ћ‚:

.... f(ўла ¦Ґ­ЁҐ1, ўла ¦Ґ­ЁҐ2, ўла ¦Ґ­ЁҐ3) ...

’Ћ ‚ ’…‹… ”“ЌЉ–€€ ‚›ЏЋ‹Ќ€’‘џ (ў ¬®¬Ґ­в ҐҐ ўл§®ў ):

 аЈ1 = ўла ¦Ґ­ЁҐ1;
 аЈ2 = ўла ¦Ґ­ЁҐ2;
 аЈ3 = ўла ¦Ґ­ЁҐ3;

ЇҐаҐ¬1 = Њ“‘Ћђ;
ЇҐаҐ¬2 = Њ“‘Ћђ;

...
/* Їа®¤®«¦Ґ­ЁҐ */

---------------------------------------------------------------------------

ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…
=====================

Ќ Є®­Ґж, бгйҐбвўгов ЇҐаҐ¬Ґ­­лҐ, Є®в®алҐ ®Ўкпў«повбп ‚Ќ… ‚‘…• ”“ЌЉ–€‰,
Ё бгйҐбвўгойЁҐ ўбҐ ўаҐ¬п ўлЇ®«­Ґ­Ёп Їа®Ја ¬¬л
(  ­Ґ в®«мЄ® в® ўаҐ¬п, Є®Ј¤   ЄвЁў­  дг­ЄжЁп, ў Є®в®а®© ®­Ё ᮧ¤ ­л).

‹®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ Ё  аЈг¬Ґ­вл “Ќ€—’Ћ†Ђћ’‘џ ЇаЁ ўл室Ґ
Ё§ дг­ЄжЁЁ. ѓ«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ - ­Ґв.

int x = 12; /* ::x - Ґ© ¬®¦­® § а ­ҐҐ ЇаЁбў®Ёвм Є®­бв ­вг */
int globvar; /* ::globvar */

int f1(){
int x; /* f1::x */

x = 77;
printf("x=%d\n", x); /* 4 */
return x;
}

int f2(){
printf("x=%d\n", x); /* 5 */
return 0;
}

void main(){
int x, y; /* main::x */

x = 111; /* 1 */
printf("x=%d\n", x); /* 2 */
printf("glob=%d\n", globvar); /* 3 */

y = f1();
y = f2();
}

‚ ¤ ­­®¬ ЇаЁ¬ҐаҐ ¬л ўЁ¤Ё¬:
- ў®-ЇҐаўле ¬л ўЁ¤Ё¬ ”“ЌЉ–€€ Ѓ…‡ ЏЂђЂЊ…’ђЋ‚. ќв® ­®а¬ «м­ п бЁвг жЁп.
- ў®-ўв®але вгв ЁбЇ®«м§говбп ’ђ€ ЇҐаҐ¬Ґ­­лҐ б Ё¬Ґ­Ґ¬ "x".

Љ Є ўлЇ®«­пҐвбп Їа®Ја ¬¬ ?

/* 1 */ main::x = 111;
ќв® «®Є «м­л© x,   ­Ґ Ј«®Ў «м­л©.
ѓ«®Ў «м­л© x Ї®ЇаҐ¦­Ґ¬г ᮤҐа¦Ёв 12.

/* 2 */ Ќ ЇҐз в Ґв §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© main::x, в® Ґбвм 111.
‚­гваЁ дг­ЄжЁЁ main Ј«®Ў «м­ п ЇҐаҐ¬Ґ­­ п ::x
§ б«®­Ґ­  бў®Ґ© б®Ўб⢥­­®© ЇҐаҐ¬Ґ­­®© x.
‚ ¤ ­­®¬ б«гз Ґ Ќ…’ ‘ЏЋ‘ЋЃЂ ¤®Ўа вмбп Ё§ main Є Ј«®Ў «м­®©
ЇҐаҐ¬Ґ­­®© x, нв® ў®§¬®¦­® в®«мЄ® ў п§лЄҐ ‘Ё++ Ї® Ё¬Ґ­Ё ::x

Љ ЇҐаҐ¬Ґ­­®© ¦Ґ globvar г ­ б ¤®бвгЇ Ґбвм.

/* 3 */ ЏҐз в Ґв ::globvar. Њл ®Ў­ аг¦Ёў Ґ¬, зв® ҐҐ §­ зҐ­ЁҐ 0.
‚ ®в«ЁзЁҐ ®в Ј«®Ў «м­ле ЇҐаҐ¬Ґ­­ле,
Є®в®алҐ Ё§­ з «м­® ᮤҐа¦ в Њ“‘Ћђ,
Ј«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ Ё§­ з «м­® ᮤҐа¦ в §­ зҐ­ЁҐ 0.

‚ а ¬®зЄг, Ї®¤зҐаЄ­гвм.

/* 4 */ ЏаЁ ўл§®ўҐ f1()
ЇҐаҐ¬Ґ­­ п f1::x
§ б«®­пҐв б®Ў®© Є Є
main::x
в Є Ё
::x

‚ ¤ ­­®¬ б«гз Ґ ­ ЇҐз в Ґвбп 77,
­® ­Ё ::x ­Ё main::x ­Ґ Ўг¤гв Ё§¬Ґ­Ґ­л ®ЇҐа в®а®¬ x = 77.
ќв® Ё§¬Ґ­п« бм f1::x

/* 5 */ ЏаЁ ўл§®ўҐ f2() Ёбв®аЁп Ё­вҐаҐб­ҐҐ.
’гв ­Ґв бў®Ґ© б®Ўб⢥­­®© ЇҐаҐ¬Ґ­­®© x.
Ќ® Є Є п ЇҐаҐ¬Ґ­­ п ЇҐз в Ґвбп вгв -
::x Ё«Ё
main::x ?

ЋвўҐв: ::x
в® Ґбвм 12.

ЏҐаҐ¬Ґ­­лҐ ­ §ў ­л «®Є «м­л¬Ё ҐйҐ Ё Ї®в®¬г,
зв® ®­Ё Ќ…‚€„€Њ› ‚ ‚›‡›‚Ђ…Њ›• ”“ЌЉ–€џ•.

ќв® ЋЏђ…„…‹…Ќ€… «®Є «м­ле ЇҐаҐ¬Ґ­­ле.
(Џ®н⮬㠭Ґ бЇа иЁў ©вҐ "Ї®зҐ¬г?" Џ® ®ЇаҐ¤Ґ«Ґ­Ёо)

’® Ґбвм, Ґб«Ё ¬л Ё¬ҐҐ¬

funca(){
int vara;
...
...funcb();... /* ўл§®ў */
...
}

в® Ё§ дг­ЄжЁЁ funcb() ¬л Ќ… €Њ……Њ „Ћ‘’“ЏЂ Љ Џ…ђ…Њ…ЌЌЋ‰ vara.

funcb(){
int z;

z = vara + 1; /* ®иЁЎЄ ,
vara ­ҐЁ§ўҐбв­  ў­гваЁ funcb() */
}

…б«Ё, ў бў®о ®зҐаҐ¤м, funcb() ўл§лў Ґв funcc(),
в® Ё Ё§ funcc() ЇҐаҐ¬Ґ­­ п vara ­ҐўЁ¤Ё¬ .

Ћбв ­®ўЁвҐбм Ё ®б®§­ ©вҐ.
ќв® Їа ўЁ«® б«г¦Ёв ўбҐ в®© ¦Ґ 楫Ё - а §­лҐ дг­ЄжЁЁ
¬®Јгв Ўлвм ­ ЇЁб ­л а §­л¬Ё Їа®Ја ¬¬Ёбв ¬Ё, Є®в®алҐ ¬®Јгв
ЁбЇ®«м§®ў вм ®¤­Ё Ё ⥠¦Ґ Ё¬Ґ­  ¤«п ђЂ‡Ќ›• ЇҐаҐ¬Ґ­­ле,
­Ґ Ў®пбм Ёе ў§ Ё¬®ЇҐаҐбҐзҐ­Ёп.
Њ­®¦Ґбвў  Ё¬Ґ­, ЁбЇ®«м§®ў ­­ле ў а §­ле дг­ЄжЁпе, ­Ґ§ ўЁбЁ¬л
¤агЈ ®в ¤агЈ . €¬Ґ­  Ё§ ®¤­®© дг­ЄжЁЁ Ќ€ЉЂЉ ­Ґ ®в­®бпвбп
Є ЇҐаҐ¬Ґ­­л¬ б ⥬Ё ¦Ґ Ё¬Ґ­ ¬Ё €‡ „ђ“ѓЋ‰ дг­ЄжЁЁ.

‚Ґа­Ґ¬бп Є Ї а Ја дг ЉЂЉ ЏђЋ€‘•Ћ„€’ ‚›‡Ћ‚ ”“ЌЉ–€€
Ё а бᬮваЁ¬ Їг­Єв (a). ’ҐЇҐам ®­ ¬®¦Ґв Ўлвм ®ЇЁб ­ Є Є

(a) ‹®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ Ё  аЈг¬Ґ­вл ўл§лў о饩 дг­ЄжЁЁ ¤Ґ« овбп ­ҐўЁ¤Ё¬л¬Ё.
~~~~~~~~~~
Ђ ЇаЁ ў®§ўа вҐ Ё§ дг­ЄжЁЁ:

(5) ‹®Є «м­лҐ ЇҐаҐ¬Ґ­­лҐ Ё  аЈг¬Ґ­вл ўл§лў о饩 дг­ЄжЁЁ б­®ў  ¤Ґ« овбп ўЁ¤Ё¬л¬Ё.

Ћ„ЌЂЉЋ Ј«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ ўЁ¤Ё¬л Ё§ ‹ћЃЋ‰ дг­ЄжЁЁ,
ЁбЄ«оз п б«гз ©, Є®Ј¤  Ј«®Ў «м­ п ЇҐаҐ¬Ґ­­ п § б«®­Ґ­ 
®¤­®Ё¬Ґ­­®© «®Є «м­®© ЇҐаҐ¬Ґ­­®© ¤ ­­®© дг­ЄжЁЁ.

---------------------------------------------------------------------------

ЏђЋ–…„“ђ›
=========
Ѓлў ов дг­ЄжЁЁ, Є®в®алҐ ­Ґ ў®§ўа й ов ­ЁЄ Є®Ј® §­ зҐ­Ёп.
’ ЄЁҐ дг­ЄжЁЁ ®Ў®§­ з овбп void ("ЇгбвлиЄ ").
’ ЄЁҐ дг­ЄжЁЁ ­ §лў ов ҐйҐ ЏђЋ–…„“ђЂЊ€.

void func(){
printf("ЏаЁўҐвЁЄ!\n");
return; /* ўҐа­гвмбп ў ўл§лў ойго дг­ЄжЁо */
}

’ ЄЁҐ дг­ЄжЁЁ ўл§лў овбп а ¤Ё "Ї®Ў®з­ле нд䥪⮢",
­ ЇаЁ¬Ґа ЇҐз вЁ бва®зЄЁ ­  нЄа ­ Ё«Ё Ё§¬Ґ­Ґ­Ёп Ј«®Ў «м­ле (Ё в®«мЄ®)
ЇҐаҐ¬Ґ­­ле.

int glob;

void func(int a){
glob += a;
}

ЋЇҐа в®а return вгв ­Ґ®Ўп§ вҐ«Ґ­, ®­  ўв®¬ вЁзҐбЄЁ ўлЇ®«­пҐвбп
ЇҐаҐ¤ Ї®б«Ґ¤­Ґ© бЄ®ЎЄ®© }

‚맮ў в ЄЁе дг­ЄжЁ© ­Ґ ¬®¦Ґв Ўлвм ЁбЇ®«м§®ў ­
ў ®ЇҐа в®аҐ ЇаЁбў Ёў ­Ёп:

main(){
int z;

z = func(7); /* ®иЁЎЄ ,   зв® ¬л ЇаЁбў Ёў Ґ¬ ??? */
}

Љ®а४в­л© ўл§®ў в Є®ў:

main(){
func(7);
}

Џа®бв® ўл§®ў Ё ўбҐ.

‡Ђ—…Њ ”“ЌЉ–€€?

—в®Ўл ўл§лў вм Ёе б а §­л¬Ё  аЈг¬Ґ­в ¬Ё!

int res1, res2;
...

res1 = func(12 * x * x + 177, 865, 'x');
res2 = func(432 * y + x, 123 * y - 12, 'z');

Љбв вЁ, ўл § ¬ҐвЁ«Ё, зв® бЇЁб®Є д ЄвЁзҐбЄЁе Ї а ¬Ґва®ў
б«Ґ¤гҐв зҐаҐ§ § Їпвго;
Ё ўла ¦Ґ­Ё© а®ў­® бв®«мЄ®, бЄ®«мЄ® Ї а ¬Ґва®ў г дг­ЄжЁЁ?

”г­ЄжЁп ®ЇЁблў Ґв ЏЋ‘‹…„Ћ‚Ђ’…њЌЋ‘’њ „…‰‘’‚€‰,
Є®в®аго ¬®¦­® ўлЇ®«­Ёвм ¬­®Ј® а §,
­® б а §­л¬Ё Ёб室­л¬Ё ¤ ­­л¬Ё ( аЈг¬Ґ­в ¬Ё).
‚ § ўЁбЁ¬®бвЁ ®в ¤ ­­ле ®­  Ўг¤Ґв ўл¤ ў вм а §­лҐ १г«мв вл,
­® ўлЇ®«­пп ®¤­Ё Ё ⥠¦Ґ ¤Ґ©бвўЁп.

‚ ⮬ в® Ё б®бв®Ёв ҐҐ ЇаҐ«Ґбвм:
¬л ­Ґ ¤гЎ«Ёа㥬 ®¤Ё­ Єгб®Є Їа®Ја ¬¬л ¬­®Ј® а §,
  Їа®бв® "ўл§лў Ґ¬" ҐЈ®.

”г­ЄжЁп -  Ўбва ЄжЁп Ђ‹ѓЋђ€’ЊЂ, в® Ґбвм Ї®б«Ґ¤®ў вҐ«м­®бвЁ ¤Ґ©бвўЁ©.
…Ґ Є®­ЄаҐвЁ§ жЁп - ўл§®ў дг­ЄжЁЁ б 㦥 ®ЇаҐ¤Ґ«Ґ­­л¬Ё Ї а ¬Ґва ¬Ё.
---------------------------------------------------------------------------

ЋЇҐа в®а return ¬®¦Ґв ­ е®¤Ёвмбп ­Ґ в®«мЄ® ў Є®­жҐ дг­ЄжЁЁ,
­® Ё ў ҐҐ бҐаҐ¤Ё­Ґ.
Ћ­ ўл§лў Ґв ­Ґ¬Ґ¤«Ґ­­®Ґ ЇаҐЄа йҐ­ЁҐ ⥫  дг­ЄжЁЁ Ё ў®§ўа в §­ зҐ­Ёп
ў в®зЄг ўл§®ў .

int f(int x){
int y;

y = x + 4;
if(y > 10) return (x - 1);
y *= 2;
return (x + y);
}

ђ…Љ“ђ‘€‚Ќ›… ”“ЌЉ–€€. ‘’…Љ

ђҐЄгабЁў­®© ­ §лў Ґвбп дг­ЄжЁп, ўл§лў ой п б ¬  ᥡп.

int factorial(int arg){
if(arg == 1)
return 1; /* a */
else
return arg * factorial(arg - 1); /* b */
}

ќв  дг­ЄжЁп ЇаЁ ўл§®ўҐ factorial(n) ўлзЁб«Ёв Їа®Ё§ўҐ¤Ґ­ЁҐ

n * (n-1) * ... * 3 * 2 * 1

­ §лў Ґ¬®Ґ "д Єв®аЁ « зЁб«  n".
‚ ¤ ­­®© дг­ЄжЁЁ ЇҐаҐ¬Ґ­­ п arg Ўг¤Ґв ®вўҐ¤Ґ­  (  Ї®б«Ґ Ё г­Ёз⮦Ґ­ ) ЊЌЋѓЋ ђЂ‡.

’ Є зв® ЇҐаҐ¬Ґ­­ п factorial::arg ¤®«¦­  Ї®«гзЁвм ҐйҐ Ё ЌЋЊ…ђ ўл§®ў  дг­ЄжЁЁ:

factorial::arg[га®ўҐ­м_ўл§®ў ]

€ ­  Є ¦¤®¬ ­®ў®¬ га®ў­Ґ ­®ў п ЇҐаҐ¬Ґ­­ п бЄалў Ґв ўбҐ ЇаҐ¤л¤гйЁҐ.
’ Є ¤«п factorial(4) Ўг¤Ґв

+----------------------------------------+
| | factorial::arg[ 0_®©_а § ] Ґбвм 4 |
| | factorial::arg[ 1_л©_а § ] Ґбвм 3 |
| | factorial::arg[ 2_®©_а § ] Ґбвм 2 |
| | factorial::arg[ 3_Ё©_а § ] Ґбвм 1 |
V --------+ +---------

‡ вҐ¬ Ї®©¤гв ў®§ўа вл Ё§ дг­ЄжЁ©:

+----------------------------------------+
A | /* b */ return 4 * 6 = 24 |
| | /* b */ return 3 * 2 = 6 |
| | /* b */ return 2 * 1 = 2 |
| | /* a */ return 1; |
| --------+ +---------

’ Є п Є®­бвагЄжЁп ­ §лў Ґвбп ‘’…Љ (stack).

--------+ +------------
| | Їгбв®© б⥪
+---------------+

Џ®«®¦Ё¬ ў б⥪ §­ зҐ­ЁҐ a
|
--------+ | +------------
| V |
+---------------+
| a | <--- ўҐаиЁ­  б⥪ 
+---------------+

Џ®«®¦Ё¬ ў б⥪ §­ зҐ­ЁҐ b

--------+ +------------
| |
+---------------+
| b | <--- ўҐаиЁ­  б⥪ 
+---------------+
| a |
+---------------+

Џ®«®¦Ё¬ ў б⥪ §­ зҐ­ЁҐ c

--------+ +------------
| |
+---------------+
| c | <--- ўҐаиЁ­  б⥪ 
+---------------+
| b |
+---------------+
| a |
+---------------+

Ђ­ «®ЈЁз­®, §­ зҐ­Ёп "б­Ё¬ овбп б® б⥪ " ў ®Ўа в­®¬ Ї®ап¤ЄҐ: c, b, a.

‚ Є ¦¤л© ¬®¬Ґ­в ўаҐ¬Ґ­Ё г б⥪  ¤®бвгЇ­® ¤«п з⥭Ёп (Є®ЇЁа®ў ­Ёп) Ё«Ё
ўлЎа блў ­Ёп в®«мЄ® ¤ ­­®Ґ, ­ е®¤п饥бп ­  ‚…ђ€Ќ… б⥪ .

’ Є Ё ў ­ иҐ© ४габЁў­®© дг­ЄжЁЁ ЇҐаҐ¬Ґ­­ п factorial::arg
ўҐ¤Ґв бҐЎп Ё¬Ґ­­® Є Є б⥪ (нв®в пйЁЄ-б⥪ Ё¬ҐҐв Ё¬п arg) -
®­  Ё¬ҐҐв Ћ„ЌЋ Ё¬п, ­® а §­лҐ §­ зҐ­Ёп ў а §­ле б«гз пе.
ЏҐаҐ¬Ґ­­лҐ, Є®в®алҐ Ђ‚’ЋЊЂ’€—…‘Љ€ ўҐ¤гв бҐЎп Є Є б⥪,
ўбваҐз овбп в®«мЄ® ў (४габЁў­ле) дг­ЄжЁпе.

‘⥪ - нв® з бв® ўбваҐз ой пбп ў Їа®Ја ¬¬Ёа®ў ­ЁЁ Є®­бвагЄжЁп.
…б«Ё Ї®¤®Ў­®Ґ Ї®ўҐ¤Ґ­ЁҐ ­г¦­® Їа®Ја ¬¬Ёбвг, ®­ ¤®«¦Ґ­ Їа®¬®¤Ґ«Ёа®ў вм
б⥪ ЇаЁ Ї®¬®йЁ ¬ ббЁў :

int stack[10];
int in_stack = 0; /* бЄ®«мЄ® н«Ґ¬Ґ­в®ў ў б⥪Ґ */

/* ‡ ­ҐбҐ­ЁҐ §­ зҐ­Ёп ў б⥪ */
void push(int x){
stack[in_stack] = x;
in_stack++;
}

/* ‘­пвм §­ зҐ­ЁҐ б® б⥪  */
int pop(){
if(in_stack == 0){
printf("‘⥪ Їгбв, ®иЁЎЄ .\n");
return (-1);
}
in_stack--;
return stack[in_stack];
}

ЋЎа вЁвҐ ў ­Ё¬ ­ЁҐ, зв® ­Ґв ­г¦¤л ‘’€ђЂ’њ (­ ЇаЁ¬Ґа ®Ў­г«пвм)
§­ зҐ­Ёп н«Ґ¬Ґ­в®ў ¬ ббЁў , ўлЄЁ­гвле б ўҐаиЁ­л б⥪ .
Ћ­Ё Їа®бв® Ў®«миҐ ­Ґ ЁбЇ®«м§говбп, «ЁЎ® § вЁа овбп ­®ўл¬ §­ зҐ­ЁҐ¬ ЇаЁ
Ї®¬ҐйҐ­ЁЁ ­  б⥪ ­®ў®Ј® §­ зҐ­Ёп.

void main(){
push(1);
push(2);
push(3);

while(in_stack > 0){
printf("top=%d\n", pop());
}
}

‘’…Љ € ”“ЌЉ–€€

Ѓг¤Ґ¬ а бб¬ ваЁў вм Є ¦¤л© ‚›‡Ћ‚ дг­ЄжЁЁ Є Є Ї®¬ҐйҐ­ЁҐ ў бЇҐжЁ «м­л© б⥪
Ў®«ми®Ј® "Ў«®Є  Ё­д®а¬ жЁЁ", ўЄ«оз о饣® ў з бв­®бвЁ
Ђђѓ“Њ…Ќ’› € ‹ЋЉЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›… ўл§лў Ґ¬®© дг­ЄжЁЁ.

ЋЇҐа в®а return Ё§ ўл§ў ­­®© дг­ЄжЁЁ ўлв «ЄЁў Ґв б® б⥪  ‚…‘њ в Є®© Ў«®Є.

‚ Є зҐб⢥ ЇаЁ¬Ґа  а бᬮваЁ¬ в Єго Їа®Ја ¬¬г:

int x = 7; /* Ј«®Ў «м­ п */
int v = 333; /* Ј«®Ў «м­ п */

int factorial(int n){
int w; /* «Ёи­пп ЇҐаҐ¬Ґ­­ п, в®«мЄ® ¤«п ¤Ґ¬®­бва жЁ®­­ле 楫Ґ© */

w = n;

if(n == 1) return 1; /* #a */
else return n * factorial(n-1); /* #b */
}
void func(){
int x; /* func::x */

x = 777; /* #c */
printf("‚л§ў ­  дг­ЄжЁп func()\n");
}
void main(){
int y = 12; /* main::y */
int z;

/* A */
z = factorial(3); /* B */
printf("z=%d\n", z);

func(); /* C */
}
---------------------------------------------------------------------------

‚лЇ®«­Ґ­ЁҐ Їа®Ја ¬¬л ­ з­Ґвбп б ўл§®ў  дг­ЄжЁЁ main().
‚ в®зЄҐ /* A */

| ў § Ј « п ¤ |
V V

--------+ +--------
|=======================|
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

‚ Є ¦¤л© ¤ ­­л© ¬®¬Ґ­в ўЁ¤Ё¬л ЇҐаҐ¬Ґ­­лҐ, Є®в®алҐ ­ е®¤пвбп
a) ­  ўҐаиЁ­Ґ (Ё в®«мЄ®) б⥪  ўл§®ў®ў дг­ЄжЁ©.
b) Ё ­Ґ§ б«®­Ґ­­лҐ Ё¬Ё Ј«®Ў «м­лҐ ЇҐаҐ¬Ґ­­лҐ.
‚ ¤ ­­®¬ б«гз Ґ ¬л ᬮваЁ¬ "ᢥаег" Ё ўЁ¤Ё¬:

main::z, main::y, ::x, ::v

---------------------------------------------------------------------------

‚ в®зЄҐ /* B */ ¬л ўл§лў Ґ¬ factorial(3).

--------+ +--------
|=======================|
| w = ¬гб®а |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

ЏаЁ ­®ў®¬ ў§Ј«п¤Ґ ўЁ¤Ё¬л:
factorial(3)::w, factorial(3)::n, ::x, ::v

‘в «Ё ­ҐўЁ¤Ё¬л:
main::z, main::y

‘ва®Є  "⥪гйЁ© ®ЇҐа в®а ..." гЄ §лў Ґв ¬Ґбв®, б Є®в®а®Ј® ­ ¤® ў®§®Ў­®ўЁвм
ўлЇ®«­Ґ­ЁҐ дг­ЄжЁЁ, Є®Ј¤  ¬л ўҐа­Ґ¬бп ў ­ҐҐ.
---------------------------------------------------------------------------

Љ®Ј¤  ўлЇ®«­Ґ­ЁҐ Їа®Ја ¬¬л ў дг­ЄжЁЁ factorial(3) ¤®©¤Ґв ¤® в®зЄЁ
/* #b */ Ўг¤Ґв ўлЇ®«­пвмбп return 3 * factorial(2).
‚ Ёв®ЈҐ Ўг¤Ґв ўл§ў ­  дг­ЄжЁп factorial(2).

--------+ +--------
|=======================|
| w = ¬гб®а |
| n = 2 |
|factorial(2) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 3 * factorial(2);
| w = 3 |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

---------------------------------------------------------------------------

Љ®Ј¤  ўлЇ®«­Ґ­ЁҐ Їа®Ја ¬¬л ў дг­ЄжЁЁ factorial(2) ¤®©¤Ґв ¤® в®зЄЁ
/* #b */ Ўг¤Ґв ўлЇ®«­пвмбп return 2 * factorial(1).
‚ Ёв®ЈҐ Ўг¤Ґв ўл§ў ­  дг­ЄжЁп factorial(1).

--------+ +--------
|=======================|
| w = ¬гб®а |
| n = 1 |
|factorial(1) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 2 * factorial(1);
| w = 2 |
| n = 2 |
|factorial(2) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 3 * factorial(2);
| w = 3 |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

---------------------------------------------------------------------------

‡ вҐ¬ ў factorial(1) ўлЇ®«­Ґ­ЁҐ Їа®Ја ¬¬л ¤®©¤Ґв ¤® в®зЄЁ /* #a */
Ё Ўг¤Ґв Їа®Ё§ў®¤Ёвмбп return 1.

ЏаЁ return ўлзҐаЄЁў Ґвбп Ћ„€Ќ Ў«®Є Ё­д®а¬ жЁЁ б® б⥪  ўл§®ў®ў дг­ЄжЁ©,
Ё ў®§®Ў­®ў«пҐвбп ўлЇ®«­Ґ­ЁҐ "⥪г饣® ®ЇҐа в®а " ў дг­ЄжЁЁ,
б⠢襩 ЌЋ‚Ћ‰ ўҐаиЁ­®© б⥪  ўл§®ў®ў.
‡ ¬ҐвмвҐ, зв® ў ¤ ­­®© бЁвг жЁЁ ўл§ў ­­лҐ дг­ЄжЁЁ factorial(m) ҐйҐ ­Ґ § ўҐаиЁ«Ёбм.
‚ ­Ёе ҐйҐ …‘’њ з⮠ᤥ« вм: ўлзЁб«Ёвм ўла ¦Ґ­ЁҐ ў return,
Ё б®Ўб⢥­­® ўлЇ®«­Ёвм б ¬ return. ‚лзЁб«Ґ­Ёп Ўг¤г⠯த®«¦Ґ­л.

--------+ +--------
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 1;
| w = 1 |
| n = 1 |
|factorial(1) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 2 * factorial(1);
| w = 2 |
| n = 2 |
|factorial(2) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 3 * factorial(2);
| w = 3 |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

---------------------------------------------------------------------------

Ќ зЁ­ Ґвбп ўлв «ЄЁў ­ЁҐ дг­ЄжЁ© б® б⥪  Ё ўлЇ®«­Ґ­ЁҐ ®ЇҐа в®а®ў return;

--------+ +--------
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 2 * 1;
| w = 2 |
| n = 2 |
|factorial(2) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 3 * factorial(2);
| w = 3 |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

--------+ +--------
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а return 3 * 2;
| w = 3 |
| n = 3 |
|factorial(3) |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = factorial(3);
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

--------+ +--------
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а z = 6;
| z = ¬гб®а |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

--------+ +--------
|=======================|
| z = 6 |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

---------------------------------------------------------------------------

Ќ Є®­Ґж, ў в®зЄҐ /* C */ Ўг¤Ґв ўл§ў ­  дг­ЄжЁп func().
ђ бᬮваЁ¬ в®зЄг /* #c */ ў ­Ґ©.

--------+ +--------
|=======================|
| x = 777; |
|func(); |
|=======================|
| +-|---> ⥪гйЁ© ®ЇҐа в®а func();
| z = 6 |
| y = 12 | +------+---------+
|main() | |x = 7 | v = 333 |
+-----------------------+-----------+------+---------+-----
‘’…Љ ‚›‡Ћ‚Ћ‚ ”“ЌЉ–€‰ ѓ‹ЋЃЂ‹њЌ›… Џ…ђ…Њ…ЌЌ›…

‚ ¤ ­­®¬ ¬Ґб⥠­ б Ё­вҐаҐбгҐв - Є ЄЁҐ ЇҐаҐ¬Ґ­­лҐ ўЁ¤Ё¬л?
‚Ё¤Ё¬л:
func::x = 777
::v = 333

€ ўбҐ.
::x § б«®­Ґ­ «®Є «м­®© ЇҐаҐ¬Ґ­­®©.
main::y, main::z ­ҐўЁ¤Ё¬л, в Є Є Є ­ е®¤пвбп
­Ґ ­  ўҐаиЁ­Ґ б⥪  ўл§®ў®ў дг­ЄжЁ©
---------------------------------------------------------------------------

Њ­®ЈЁҐ дг­ЄжЁЁ Ў®«ҐҐ ҐбвҐб⢥­­® ўла ¦ овбп зҐаҐ§ ४габЁо.
•®вп, з бв® нв® ЇаЁў®¤Ёв Є Ё§«Ёи­Ё¬ ўлзЁб«Ґ­Ёп¬ Ї® ба ў­Ґ­Ёо б ЁвҐа жЁп¬Ё
(в® Ґбвм жЁЄ« ¬Ё). ‚®в ЇаЁ¬Ґа - зЁб«  ”ЁЎ®­ ззЁ.

int fibonacci(int n){
if(n==1 || n==2) return 1;

/* else */

return fibonacci(n-1) + fibonacci(n-2);
}
void main(){
printf("20®Ґ зЁб«® ”ЁЎ®­ ззЁ а ў­® %d\n", fibonacci(20));
}

Џ®бЄ®«мЄг вгв ®вбгвбвўгҐв ¬ ббЁў ¤«п § Ї®¬Ё­ ­Ёп Їа®¬Ґ¦гв®з­ле
१г«мв в®ў, в® нв®в ¬ ббЁў ­  б ¬®¬ ¤Ґ«Ґ ­Ґпў­® ¬®¤Ґ«ЁагҐвбп
ў ўЁ¤Ґ «®Є «м­ле ЇҐаҐ¬Ґ­­ле ў­гваЁ б⥪  ўл§®ў®ў дг­ЄжЁ©.
Ћ¤­ Є® нв®в бЇ®б®Ў Ї«®е - ў ­Ґ¬ б«ЁиЄ®¬ ¬­®Ј® Ї®ўв®апойЁебп
¤Ґ©бвўЁ©. „®Ў ўЁ¬ ®ЇҐа в®а ЇҐз вЁ - Ё Ї®бзЁв Ґ¬, бЄ®«мЄ® а §
Ўл«  ўл§ў ­  fibonacci(1) ?

int called = 0;

int fibonacci(int n){
if(n==1){
called++;
return 1;

} else if(n==2)
return 1;

return fibonacci(n-1) + fibonacci(n-2);
}
void main(){
printf("20®Ґ зЁб«® ”ЁЎ®­ ззЁ а ў­® %d\n", fibonacci(20));
printf("fibonacci(1) Ўл«  ўл§ў ­  %d а §\n", called);
}

Ћ­  Ўл«  ўл§ў ­ ... 2584 а § !
14.c

/* ђЁб㥬 еЁваго ЈҐ®¬ҐваЁзҐбЄго дЁЈгаг */
#include

const int LINES = 15;

void draw(int nspaces, int nstars, char symbol){
int i;

for(i=0; i < nspaces; i++)
putchar(' ');
for(i=0; i < nstars; i++)
putchar(symbol);
}

void main(){
int nline, nsym;
char symbols[3]; /* Њ ббЁў Ё§ ваҐе ЎгЄў */

symbols[0] = '\\';
symbols[1] = 'o';
symbols[2] = '*';

for(nline=0; nline < LINES; nline++){
for(nsym = 0; nsym < 3; nsym++)
draw(nline, nline, symbols[nsym]);

/* ЏҐаҐе®¤ ­  ­®ўго бвப㠢뭥ᥭ
Ё§ дг­ЄжЁЁ ў Ј« ў­л© жЁЄ« */
putchar('\n');
}
}
15.c

/* ‡ ¤ з :
­ аЁб®ў вм в Ў«Ёжг ўЁ¤ 

Є®в Є®в Є®в Є®иЄ  Є®иЄ  Є®в
Є®в Є®в Є®иЄ  Є®иЄ  Є®в ...

ѓ¤Ґ Ё¤Ґв Ї®б«Ґ¤®ў вҐ«м­®бвм
Є®в, Є®в, Є®в, Є®иЄ , Є®иЄ ...
Ї®ўв®апой пбп ¬­®Ј® а § Ё а бЇ®« Ј Ґ¬ п Ї® 6 §ўҐаҐ© ў бва®Єг.
*/

#include /* ¬ ЈЁзҐбЄ п бва®Є  */

/* ЋЎкпў«Ґ­ЁҐ Ј«®Ў «м­ле ЇҐаҐ¬Ґ­­ле.
‚ ¤ ­­®¬ б«гз Ґ - Є®­бв ­в.
*/

int TOMCATS = 3; /* ваЁ Є®в  */
int CATS = 2; /* ¤ўҐ Є®иЄЁ */
int ANIMALS_PER_LINE = 6; /* иҐбвм §ўҐаҐ© ў Є ¦¤®© бва®ЄҐ */
int LINES = 25; /* зЁб«® ўлў®¤Ё¬ле бва®Є */

/* Ё ­ ¬ Ї®­ ¤®ЎЁвбп ҐйҐ ®¤­  ЇҐаҐ¬Ґ­­ п - ®ЎйҐҐ зЁб«® §ўҐаҐ©.
…Ґ ¬л ўлзЁб«Ё¬ зҐаҐ§ 㦥 § ¤ ­­лҐ, Ї®н⮬г вгв ¬л ҐҐ ®ЎкпўЁ¬...
­® ўлзЁб«Ёвм зв®-«ЁЎ® ¬®¦­® в®«мЄ® ў­гваЁ дг­ЄжЁЁ.
‚ ­ иҐ¬ б«гз Ґ - ў дг­ЄжЁЁ main().
*/
int ANIMALS; /* ®ЎйҐҐ зЁб«® §ўҐаҐ© */

int nth_in_line = 0; /* ­®¬Ґа §ўҐап ў ⥪г饩 бва®ЄҐ */
/* ќв  ЇҐаҐ¬Ґ­­ п ­Ґ ¬®¦Ґв Ўлвм «®Є «м­®© ў дг­ЄжЁЁ, в Є Є Є
* в®Ј¤  ®­  г­Ёз⮦Ёвбп ЇаЁ ўл室Ґ Ё§ дг­ЄжЁЁ. Ќ ¬ ¦Ґ ­Ґ®Ўе®¤Ё¬®,
* зв®Ўл ҐҐ §­ зҐ­ЁҐ б®еа ­п«®бм. Џ®н⮬㠯ҐаҐ¬Ґ­­ п - Ј«®Ў «м­ п.
*/

/* ”г­ЄжЁп, Є®в®а п бзЁв Ґв зЁб«® §ўҐаҐ© ў ®¤­®© бва®ЄҐ
Ё «ЁЎ® ЇҐаҐў®¤Ёв бва®Єг, «ЁЎ® ЇҐаҐў®¤Ёв ЇҐз вм ў
б«Ґ¤гойго Є®«®­Єг (в Ўг«пжЁҐ©).
*/
void checkIfWeHaveToBreakLine(){
nth_in_line++; /* ⥪гйЁ© ­®¬Ґа §ўҐап ў бва®ЄҐ (б Ґ¤Ё­Ёжл) */

if(nth_in_line == ANIMALS_PER_LINE){
/* …б«Ё бва®Є  § Ї®«­Ґ­  §ўҐам¬Ё... */
putchar('\n'); /* ­®ў п бва®Є  */
nth_in_line = 0; /* ў ­®ў®© бва®ЄҐ ­Ґв §ўҐаҐ© */
} else {
putchar('\t'); /* ў б«Ґ¤гойго Є®«®­Єг */
}
}

void main(){
int nanimal; /* ­®¬Ґа §ўҐап */
int i; /* бзҐвзЁЄ */

ANIMALS = ANIMALS_PER_LINE * LINES;
nanimal = 0;

while(nanimal < ANIMALS){

for(i=0; i < TOMCATS; i++){
/* ЋЇҐа в®а printf() ўлў®¤Ёв ‘’ђЋЉ“ ‘€Њ‚Ћ‹Ћ‚.
‘’ђЋЉЂ § Є«оз Ґвбп ў ¤ў®©­лҐ Є ўлзЄЁ
(­Ґ Їгв вм б ®¤Ё­®з­л¬Ё ¤«п putchar().
*/
printf("Є®в");
nanimal++; /* Ї®бзЁв вм ҐйҐ ®¤­®Ј® §ўҐап */

/* Ё Їа®ўҐаЁвм - ­Ґ ­ ¤® «Ё ЇҐаҐ©вЁ ­  ­®ўго бва®Єг ? */
checkIfWeHaveToBreakLine();
}
for(i=0; i < CATS; i++){
printf("Є®иЄ ");
nanimal++; /* Ї®бзЁв вм ҐйҐ ®¤­®Ј® §ўҐап */

/* Ё Їа®ўҐаЁвм - ­Ґ ­ ¤® «Ё ЇҐаҐ©вЁ ­  ­®ўго бва®Єг ? */
checkIfWeHaveToBreakLine();
}
}
/* putchar('\n'); */
}
16.c

/*
’  ¦Ґ § ¤ з , ­® ҐйҐ ­ ¤® ЇҐз в вм ­®¬Ґа Є ¦¤®Ј® §ўҐап.
ЋЈа ­ЁзЁ¬бп Їпвмо бва®Є ¬Ё.
*/

#include /* ¬ ЈЁзҐбЄ п бва®Є  */

int TOMCATS = 3; /* ваЁ Є®в  */
int CATS = 2; /* ¤ўҐ Є®иЄЁ */
int ANIMALS_PER_LINE = 6; /* иҐбвм §ўҐаҐ© ў Є ¦¤®© бва®ЄҐ */
int LINES = 5; /* зЁб«® ўлў®¤Ё¬ле бва®Є */
int ANIMALS; /* ®ЎйҐҐ зЁб«® §ўҐаҐ© */

int nth_in_line = 0; /* ­®¬Ґа §ўҐап ў ⥪г饩 бва®ЄҐ */

void checkIfWeHaveToBreakLine(){
nth_in_line++;

if(nth_in_line == ANIMALS_PER_LINE){
putchar('\n');
nth_in_line = 0;
} else
printf("\t\t"); /* @ */

/* Ћ¤Ё­®ЄЁ© ®ЇҐа в®а ¬®¦Ґв ®Ў®©вЁбм ЎҐ§ {...} ў®ЄагЈ ­ҐЈ® */
}

void main(){
int nanimal;
int i;

ANIMALS = ANIMALS_PER_LINE * LINES;
nanimal = 0;

while(nanimal < ANIMALS){

for(i=0; i < TOMCATS; i++){
/* ”®а¬ в %d ўлў®¤Ёв §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© вЁЇ  int
ў ўЁ¤Ґ ⥪бв®ў®© бва®ЄЁ.
‘ ¬  ЇҐаҐ¬Ґ­­ п ¤®«¦­  Ўлвм ў бЇЁбЄҐ Ї®б«Ґ д®а¬ в 
(бЇЁб®Є - нв® ЇҐаҐзЁб«Ґ­ЁҐ ЇҐаҐ¬Ґ­­ле зҐаҐ§ § Їпвго).
ЏҐаҐ¬Ґ­­ле €‹€ ўла ¦Ґ­Ё© (д®а¬г«).

„ ў ©вҐ ўлў®¤Ёвм Ї® „‚… в Ўг«пжЁЁ --
нв® ¬Ґбв® ®в¬ҐзҐ­® ў дг­ЄжЁЁ checkIfWeHaveToBreakLine()
Є Є @.

…йҐ а § ў­Ё¬ ­ЁҐ - ®¤Ё­ бЁ¬ў®« ¬л ўлў®¤Ё¬ Є Є
putchar('a');
ЌҐбЄ®«мЄ® бЁ¬ў®«®ў - Є Є
printf("abcdef");

Ћ¤Ё­®з­лҐ Є ўлзЄЁ - ¤«п ®¤­®© ЎгЄўл.
„ў®©­лҐ Є ўлзЄЁ - ¤«п ­ҐбЄ®«мЄЁе.
*/

printf("Є®в%d", nanimal);
nanimal++;

checkIfWeHaveToBreakLine();
}
for(i=0; i < CATS; i++){
printf("Є®иЄ %d", nanimal);
nanimal++;

checkIfWeHaveToBreakLine();
}
}
}
17.c

/* ‡ ¤ з : ­ ЇҐз в вм Є®а­Ё Ё§ зЁбҐ« ®в 1 ¤® 100.

Ќ®ў п Ё­д®а¬ жЁп:
Ќ ¬ Ї®­ ¤®ЎЁвбп ­®ўл© вЁЇ ¤ ­­ле - „…‰‘’‚€’…‹њЌ›… —€‘‹Ђ.
ќв® зЁб« , Ё¬ҐойЁҐ ¤а®Ў­го з бвм (Ї®б«Ґ в®зЄЁ).
Љ Є ¬л 㦥 §­ Ґ¬, жҐ«лҐ - нв® int.
ЎгЄў  - нв® char.
¤Ґ©б⢨⥫쭮Ґ зЁб«® - нв® double.
(Ґбвм ҐйҐ б«®ў® float, ­® Ё¬ Ї®«м§®ў вмбп ­Ґ ४®¬Ґ­¤гҐвбп).

„«п ўлзЁб«Ґ­Ёп Є®а­п ЁбЇ®«м§гҐвбп ЁвҐа жЁ®­­л©  «Ј®аЁв¬ ѓҐа®­ .

q = Є®аҐ­м Ё§ x;

q[0] := x;
q[n+1] := 1/2 * ( q[n] + x/q[n] );

ѓ« ў­®Ґ вгв ­Ґ ўЇ бвм ў ®иЁЎЄг, ­Ґ Є«о­гвм ­  q[n] Ё ­Ґ
§ ўҐбвЁ ¬ ббЁў. Ќ ¬ ­Ґ ­г¦­л १г«мв вл Є ¦¤®© ЁвҐа жЁЁ,
­ ¬ ­г¦Ґ­ в®«мЄ® Є®­Ґз­л© ®вўҐв. Џ®н⮬㠭 ¬ Ўг¤Ґв ўЇ®«­Ґ
¤®бв в®з­® Ћ„ЌЋ‰, ­® Ё§¬Ґ­по饩бп ў жЁЄ«Ґ, п祩ЄЁ q.
*/

#include

/* …йҐ ®¤­® ­®ў®Ґ Є«о祢®Ґ б«®ў® - const. ЋЎ®§­ з Ґв Є®­бв ­вл.
‚ ®в«ЁзЁҐ ®в ЇҐаҐ¬Ґ­­ле, в ЄЁҐ Ё¬Ґ­  ­Ґ«м§п Ё§¬Ґ­пвм.
’® Ґбвм, Ґб«Ё Ј¤Ґ-в® Ї®в®¬ Ї®Їа®Ў®ў вм ­ ЇЁб вм epsilon = ... ;
в® нв® Ўг¤Ґв ®иЁЎЄ®©.
*/
const double epsilon = 0.0000001; /* в®з­®бвм ўлзЁб«Ґ­Ё© */

/* ”г­ЄжЁп ўлзЁб«Ґ­Ёп ¬®¤г«п зЁб«  */
double doubleabs(double x){
if(x < 0) return -x;
else return x;
}

/* ”г­ЄжЁп ўлзЁб«Ґ­Ёп Єў ¤а в­®Ј® Є®а­п */
double sqrt(double x){

double sq = x;

/* ’ Є п Є®­бвагЄжЁп Ґбвм Їа®бв® бЄ«Ґ©Є  ¤ўге бва®Є:
double sq;
sq = x;
Ќ §лў Ґвбп нв® "®Ўкпў«Ґ­ЁҐ ЇҐаҐ¬Ґ­­®© б Ё­ЁжЁ «Ё§ жЁҐ©".
*/

while(doubleabs(sq*sq - x) >= epsilon){
sq = 0.5 * (sq + x/sq);
}
return sq;
}

void main() {
int n;

for(n=1; n <= 100; n++)
printf("sqrt(%d)=%lf\n",
n, sqrt((double) n)
);

}

/*
‡¤Ґбм ў ®ЇҐа в®аҐ printf() ¬л ЇҐз в Ґ¬ „‚Ђ ўла ¦Ґ­Ёп.
”ЋђЊЂ’ ‡ЌЂ—…Ќ€…
------ --------
%d -- n
%lf -- sqrt((double) n)

Џ® д®а¬ вг %d ЇҐз в овбп §­ зҐ­Ёп вЁЇ  int.
Џ® д®а¬ вг %c ЇҐз в овбп §­ зҐ­Ёп вЁЇ  char.
Џ® д®а¬ вг %lf (Ё«Ё %g) ЇҐз в овбп §­ зҐ­Ёп вЁЇ  double.

—в® §­ зЁв "­ ЇҐз в вм §­ зҐ­ЁҐ ўла ¦Ґ­Ёп sqrt(xxx)" ?
ќв® §­ зЁв:
- ўл§ў вм дг­ЄжЁо sqrt() б  аЈг¬Ґ­в®¬, а ў­л¬ xxx;
- ўлзЁб«Ёвм ҐҐ;
- ў®§ўа йҐ­­®Ґ Ґо §­ зҐ­ЁҐ ­ ЇҐз в вм Ї® д®а¬ вг %lf,
в® Ґбвм Є Є ¤Ґ©б⢨⥫쭮Ґ зЁб«®.

‡ ¬ҐвмвҐ, зв® вгв ў®§ўа й Ґ¬®Ґ §­ зҐ­ЁҐ Ќ… ЇаЁбў Ёў Ґвбп
­ЁЄ Є®© ЇҐаҐ¬Ґ­­®©, ¬л ­Ґ б®ЎЁа Ґ¬бп ҐЈ® еа ­Ёвм.

’®з­® в Є ¦Ґ, Є Є ў ®ЇҐа в®аҐ x = 12 + 34;
12 Ё 34 ­Ґ еа ­пвбп ­Ё ў Є ЄЁе ЇҐаҐ¬Ґ­­ле,
  ®ЇҐа в®а

printf("%d\n", 12);

ЇҐз в Ґв —€‘‹Ћ 12,   ­Ґ ЇҐаҐ¬Ґ­­го.

’®з­® в Є ¦Ґ, Є Є ¬®¦­® ЇЁб вм

double z;

z = sqrt(12) + sqrt(23);

Ј¤Ґ §­ зҐ­ЁҐ, ўлзЁб«Ґ­­®Ґ Є ¦¤®© дг­ЄжЁҐ©, Ќ… еа ­Ёвбп
ў бў®Ґ© б®Ўб⢥­­®© ЇҐаҐ¬Ґ­­®© (в Є п ЇҐаҐ¬Ґ­­ п ­  б ¬®¬
¤Ґ«Ґ бгйҐбвўгҐв ў Є®¬ЇмовҐаҐ, ­® Їа®Ја ¬¬Ёбвг ®­  ­Ґ
­г¦­  Ё ­Ґ¤®бвгЇ­ ).
€«Ё

z = sqrt( sqrt(81));

(Є®аҐ­м Ё§ Є®а­п Ё§ 81 --> ¤ бв 3)

„ «ҐҐ, зв® ®§­ з Ґв Є®­бвагЄжЁп (double) n ?
”г­ЄжЁп sqrt() вॡгҐв  аЈг¬Ґ­в  вЁЇ  double.
Њл ¦Ґ ЇаҐ¤« Ј Ґ¬ Ґ© жҐ«л©  аЈг¬Ґ­в

int n;

–Ґ«лҐ Ё ¤Ґ©б⢨⥫м­лҐ зЁб«  ЇаҐ¤бв ў«Ґ­л ў Ї ¬пвЁ
¬ иЁ­л ЏЋ-ђЂ‡ЌЋЊ“,
Ї®н⮬г зЁб« 

12 Ё 12.0 еа ­пвбп ў Ї ¬пвЁ ЏЋ-ђЂ‡ЌЋЊ“.

Њ иЁ­  㬥Ґв ЇаҐ®Ўа §®ўлў вм жҐ«лҐ зЁб«  ў ¤Ґ©б⢨⥫м­лҐ
Ё ­ ®Ў®а®в, ­ ¤® в®«мЄ® бЄ § вм Ґ© ®Ў н⮬.
ЋЇҐа в®а (double) x
­ §лў Ґвбп "ЇаЁўҐ¤Ґ­ЁҐ вЁЇ  Є double".

‡ ¬ҐвЁ¬, зв® з бв® ЇаҐ®Ўа §®ў ­ЁҐ вЁЇ 
ўлЇ®«­пҐвбп  ўв®¬ вЁзҐбЄЁ.

’ Є, ­ ЇаЁ¬Ґа, ЇаЁ б«®¦Ґ­ЁЁ int Ё double
int  ўв®¬ вЁзҐбЄЁ ЇаЁў®¤Ёвбп Є double, Ё १г«мв в
Ё¬ҐҐв вЁЇ double.

int var1;
double var2, var3;

var1 = 2;
var2 = 2.0;
var3 = var1 + var2;

зв® ®§­ з Ґв ­  б ¬®¬ ¤Ґ«Ґ

var3 = (double) var1 + var2;

var3 бв ­Ґв а ў­® 4.0

Ѓ®«ҐҐ в®Ј®, Є ЇаЁ¬Ґаг вЁЇ char - н⮠⮦Ґ –…‹›… —€‘‹Ђ Ё§ Ё­вҐаў « 
0...255. Љ ¦¤ п ЎгЄў  Ё¬ҐҐв Є®¤ ®в 0 ¤® 255.

*/
* 18_POINTERS.txt *

“ЉЂ‡Ђ’…‹€
=========
void f(int x){
x = 7;
}

main(){
int y = 17;
f(y);
printf("y=%d\n", y); /* ЇҐз в Ґв: y=17 */
}

‚  аЈг¬Ґ­вҐ x ЇҐаҐ¤ Лвбп ЉЋЏ€џ §­ зҐ­Ёп y,
Ї®н⮬г x=7; ­Ґ Ё§¬Ґ­пҐв §­ зҐ­Ёп г.
Љ Є ўбҐ ¦Ґ ᤥ« вм, зв®Ўл ўл§лў Ґ¬ п дг­ЄжЁп
¬®Ј«  Ё§¬Ґ­пвм §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®©?

ЋвЎа®бЁ¬ ¤ў  бЇ®б®Ў :

- ®Ўкпў«Ґ­ЁҐ y Є Є Ј«®Ў «м­®©
(¬­®Ј® Ј«®Ў «м­ле ЇҐаҐ¬Ґ­­ле - Ї«®е®© бвЁ«м),

- y=f(y);
(  зв® Ґб«Ё ­ ¤® Ё§¬Ґ­Ёвм ЊЌЋѓЋ ЇҐаҐ¬Ґ­­ле?
return, Є ­Ґбз бвмо, ¬®¦Ґв ўҐа­гвм «Ёим ®¤­® §­ зҐ­ЁҐ).

€бЇ®«м§гҐвбп ­®ў п ¤«п ­ б Є®­бвагЄжЁп: “ЉЂ‡Ђ’…‹њ.
---------------------------------------------------------------------------

ЏаЁ¬Ґа (@)

void f(int *ptr){ /* #2 */
*ptr = 7; /* #3 */
}

main (){
int y=17;

f(&y); /* #1 */
printf("y=%d\n", y); /* ЇҐз в Ґв: y=7 */
}

Ќг Є Є, ­ и«Ё ваЁ ®в«ЁзЁп ®в Ёб室­®Ј® ⥪бв ?
---------------------------------------------------------------------------

Њл ўў®¤Ё¬ ¤ўҐ ­®ўлҐ Є®­бвагЄжЁЁ:

&y "гЄ § вҐ«м ­  ЇҐаҐ¬Ґ­­го y" Ё«Ё
" ¤аҐб ЇҐаҐ¬Ґ­­®© y"

*ptr ®§­ з Ґв "ࠧ묥­®ў ­ЁҐ гЄ § вҐ«п ptr"
(Ї®¤а®Ў­ҐҐ - Ї®§¦Ґ)

int *ptr; ®§­ з Ґв ®Ўкпў«Ґ­ЁҐ ЇҐаҐ¬Ґ­­®© ptr,
Є®в®а п ¬®¦Ґв ᮤҐа¦ вм ў ᥡҐ
гЄ § вҐ«м ­  ЇҐаҐ¬Ґ­­го,
еа ­пйго int-зЁб«®.

„«п ­ з «  ®ЇаҐ¤Ґ«Ё¬, зв® в Є®Ґ гЄ § вҐ«м.

int var1, var2, z; /* 楫®зЁб«Ґ­­лҐ ЇҐаҐ¬Ґ­­лҐ */
int *pointer; /* гЄ § вҐ«м ­  楫®зЁб«Ґ­­го ЇҐаҐ¬Ґ­­го */

var1 = 12;
var2 = 43;
pointer = &var1;

Њл Ўг¤Ґ¬ Ё§®Ўа ¦ вм гЄ § вҐ«м ў ўЁ¤Ґ ‘’ђ…‹Љ€;
нв® е®а®иЁ© ЇаЁҐ¬ Ё ЇаЁ Їа ЄвЁзҐбЄ®¬ Їа®Ја ¬¬Ёа®ў ­ЁЁ.
________
/pointer/
_/_______/_
| §­ зҐ­ЁҐ| ЏҐаҐ¬Ґ­­ п, еа ­пй п гЄ § вҐ«м
| Ґбвм | ( ¤аҐб ¤агЈ®© ЇҐаҐ¬Ґ­­®©)
| |
| &var1 |
| |
|_______|_|
|
|&var1 - б ¬ гЄ § вҐ«м ­  var1 -
| "бв५Є , гЄ §лў ой п ­  ЇҐаҐ¬Ґ­­го var1".
V Ћ­  ®Ў®§­ з Ґвбп &var1
________
/ var1 /
_/_______/_
| §­ зҐ­ЁҐ|
| Ґбвм |
| 12 |
|_________|

’ ЄЁ¬ ®Ўа §®¬, “ЉЂ‡Ђ’…‹њ - нв® "бв५Є , гЄ §лў ой п ­  ­ҐЄЁ© пйЁЄ-ЇҐаҐ¬Ґ­­го".
Ќ з «® нв®© бв५ЄЁ ¬®¦­® (ў бў®о ®зҐаҐ¤м) еа ­Ёвм ў Є Є®©-­ЁЎг¤м ЇҐаҐ¬Ґ­­®©.

ЏаЁ н⮬, Ґб«Ё бв५Є  гЄ §лў Ґв ­  ЇҐаҐ¬Ґ­­го вЁЇ  int,
в® вЁЇ ЇҐаҐ¬Ґ­­®©, еа ­п饩 ­ з «® бв५ЄЁ, Ґбвм int *

…б«Ё вЁЇ  char, в® вЁЇ - char *

Ђ„ђ…‘ (гЄ § вҐ«м ­ ) ¬®¦­® ў§пвм в®«мЄ® ®в ЇҐаҐ¬Ґ­­®© Ё«Ё н«Ґ¬Ґ­в  ¬ ббЁў ,
­® ­Ґ ®в ўла ¦Ґ­Ёп.

int x;
int arr[5];

‡ Є®­­® &x бв५Є  ­  пйЁЄ "x"
& arr[3] бв५Є  ­  пйЁЄ "arr[3]"

ЌҐ§ Є®­­® &(2+2) вгв ­Ґв Ё¬Ґ­®ў ­­®Ј® "пйЁЄ ",
­  Є®в®ал© гЄ §лў Ґв бв५Є ,
¤  Ё ў®®ЎйҐ пйЁЄ  ­Ґв.

€‘ЏЋ‹њ‡Ћ‚ЂЌ€… “ЉЂ‡Ђ’…‹…‰

“Є § вҐ«Ё ­ҐбЄ®«мЄ® а §«Ёз­® ўҐ¤гв бҐЎп ‘‹…‚Ђ Ё ‘ЏђЂ‚Ђ
®в ®ЇҐа в®а  ЇаЁбў Ёў ­Ёп.
Ќ б Ё­вҐаҐбгҐв ­®ў п ®ЇҐа жЁп, ЇаЁ¬Ґ­пҐ¬ п в®«мЄ® Є гЄ § вҐ«п¬:

*pointer

---------------------------------------------------------------------------

‘ЏђЂ‚Ђ ®в ЇаЁбў Ёў ­Ё© Ё ў д®а¬г« е
===================================
*pointer ®§­ з Ґв
"ў§пвм §­ зҐ­ЁҐ ЇҐаҐ¬Ґ­­®© («Ґ¦ йҐҐ ў пйЁЄҐ),
­  Є®в®аго гЄ §лў Ґв гЄ § вҐ«м,
еа ­пйЁ©бп ў ЇҐаҐ¬Ґ­­®© pointer".

‚ ­ иҐ¬ ЇаЁ¬ҐаҐ - нв® зЁб«® 12.

’® Ґбвм *pointer ®§­ з Ґв "Їа®©вЁ Ї® бв५ЄҐ Ё ў§пвм гЄ §лў Ґ¬®Ґ Ґо ‡ЌЂ—…Ќ€…".

printf("%d\n", *pointer);

ЏҐз в Ґв 12;

z = *pointer; /* а ў­®жҐ­­® z = 12; */
z = *pointer + 66; /* а ў­®жҐ­­® z = 12 + 66; */

‡ бв ўЁ¬ ⥯Ґам гЄ § вҐ«м гЄ §лў вм ­  ¤агЈго ЇҐаҐ¬Ґ­­го
(Ё­ зҐ Ј®ў®ап, "ЇаЁбў®Ё¬ гЄ § вҐ«о  ¤аҐб ¤агЈ®© ЇҐаҐ¬Ґ­­®©")

pointer = &var2;

________
/pointer/
_/_______/_
| |
| &var2 |
| |
|_______|_|
|
|&var2
|
V
________
/ var2 /
_/_______/_
| |
| 43 |
| |
|_________|

Џ®б«Ґ нв®Ј® z = *pointer;
®§­ з Ґв z = 43;

---------------------------------------------------------------------------

’ ЄЁ¬ ®Ўа §®¬, Є®­бвагЄжЁп

z = *pointer;

®§­ з Ґв

z = *(&var2);

®§­ з Ґв

z = var2;

’® Ґбвм * Ё & ў§ Ё¬­® ‘’€ђЂћ’‘џ.

‘‹…‚Ђ ®в ЇаЁбў Ёў ­Ёп...

*pointer = 123;

Ћ§­ з Ґв "Ї®«®¦Ёвм §­ зҐ­ЁҐ Їа ў®© з бвЁ (в.Ґ. 123)
ў ЇҐаҐ¬Ґ­­го (пйЁЄ), ­  Є®в®ал© гЄ §лў Ґв гЄ § вҐ«м,
еа ­пйЁ©бп ў ЇҐаҐ¬Ґ­­®© pointer".

Џа®©вЁ Ї® бв५ЄҐ Ё Ї®«®¦Ёвм §­ зҐ­ЁҐ ў гЄ §лў Ґ¬го ЇҐаҐ¬Ґ­­го.

‚ ¤ ­­®¬ б«гз Ґ *pointer ®Ў®§­ з Ґв
­Ґ ‡ЌЂ—…Ќ€… гЄ §лў Ґ¬®© ЇҐаҐ¬Ґ­­®©,
  ‘ЂЊ“ гЄ §лў Ґ¬го ЇҐаҐ¬Ґ­­го.

________
/pointer/
_/_______/_
| |
| &var2 |
| |
|_______|_|
|
|Џ®«®¦Ёвм вг¤  123
|
V
________
/ var2 /
_/_______/_
| |
| 123 |
| |
|_________|

pointer = &var2;
*pointer = 123;

®§­ з Ґв

*(&var2) = 123;

®§­ з Ґв

var2 = 123;

’® Ґбвм б­®ў  * Ё & ў§ Ё¬­® ‘’€ђЂћ’ ¤агЈ ¤агЈ .

---------------------------------------------------------------------------

…йЛ ЇаЁ¬Ґа:

*pointer = *pointer + 66;

Ё«Ё

*pointer += 66;

---------------------------------------------------------------------------

‚Ґа­Ґ¬бп Є ЇаЁ¬Ґаг б дг­ЄжЁҐ© (@). Љ Є ®­ а Ў®в Ґв?

‚ бва®ЄҐ /* #1 */
Њл ўл§лў Ґ¬ дг­ЄжЁо f(), ЇҐаҐ¤ ў п ў ­ҐҐ
“ЉЂ‡Ђ’…‹њ ­  ЇҐаҐ¬Ґ­­го y (" ¤аҐб ЇҐаҐ¬Ґ­­®© y").

‚ бва®ЄҐ /* #2 */
Ћвў®¤Ёвбп «®Є «м­ п ЇҐаҐ¬Ґ­­ п б Ё¬Ґ­Ґ¬ ptr,
Є®в®а п ў Є зҐб⢥ ­ з «м­®Ј® §­ зҐ­Ёп
Ї®«гз Ґв §­ зҐ­ЁҐ ЇҐаў®Ј®  аЈг¬Ґ­в  дг­ЄжЁЁ ў в®зЄҐ ўл§®ў  -
в® Ґбвм “ЉЂ‡Ђ’…‹њ ­  y.

‚ бва®ЄҐ /* #3 */
Њл ўЁ¤Ё¬
*ptr = 7;

зв® б«Ґ¤гҐв а бб¬ ваЁў вм Є Є

*(&y) = 7; в®з­ҐҐ *(&main::y)=7;

в® Ґбвм Є Є

y = 7; в®з­ҐҐ main::y=7;

—в® Ё е®вҐ«®бм.

ЏаЁ н⮬ ®в¬ҐвЁ¬, зв® б ¬® Ё¬п "y" нв®© ЇҐаҐ¬Ґ­­®©
ў­гваЁ дг­ЄжЁЁ f() Ќ…‚€„€ЊЋ Ё Ќ…€‡‚…‘’ЌЋ!

---------------------------------------------------------------------------

Џђ€Њ…ђ: ®Ў¬Ґ­ §­ зҐ­Ё© ¤ўге ЇҐаҐ¬Ґ­­ле.

void main(){
int x, y;
int temporary; /* ўбЇ®¬®Ј вҐ«м­ п ЇҐаҐ¬Ґ­­ п */

x=1; y=2;

temporary=x; x=y; y=temporary;
printf("x=%d y=%d\n", x, y); /* ЏҐз в Ґв x=2 y=1 */
}
---------------------------------------------------------------------------

’ҐЇҐам в® ¦Ґ б ЁбЇ®«м§®ў ­ЁҐ¬  ¤аҐб®ў Ё гЄ § вҐ«Ґ©:

void swap(int *a, int *b){
int tmp;

tmp = *a; *a = *b; *b = tmp;
}

void main(){
int x, y;

x = 1; y = 2;
swap(&x, &y);
printf("x=%d y=%d\n", x, y);
}
---------------------------------------------------------------------------

…йЛ ЇаЁ¬Ґа:

int x;
int *ptr1, *ptr2;

ptr1 = &x; ptr2 = &x;
*ptr1 = 77;
printf("%d\n", *ptr2); /* ЏҐз в Ґв 77 */

’® Ґбвм ­  ®¤­г ЇҐаҐ¬Ґ­­го ЊЋѓ“’ гЄ §лў вм ­ҐбЄ®«мЄ® гЄ § вҐ«Ґ©.
---------------------------------------------------------------------------

…йЛ ЇаЁ¬Ґа:
int x;
int *ptr1; /* ЌҐ Ё­ЁжЁ «Ё§Ёа®ў ­  */

x = *ptr1;

‚ ptr1 ­Ґв гЄ § вҐ«п ­Ё ­  зв®, в ¬ Ґбвм ¬гб®а.
“Є § вҐ«м гЄ §лў Ґв "ў ­ЁЄг¤ " (Ї «м楬 ў ­ҐЎ®).
‘Є®аҐҐ ўбҐЈ® Їа®Ё§®©¤Лв бЎ®© ў а Ў®вҐ Їа®Ја ¬¬л.

Њ®а «м: ‚‘…ѓ„Ђ Ё­ЁжЁ «Ё§Ёаг© ЇҐаҐ¬Ґ­­лҐ, гЄ § вҐ«Ё ў ⮬ зЁб«Ґ.

ЊЂ‘‘€‚›

џ§лЄ ‘Ё а Ў®в Ґв б Ё¬Ґ­ ¬Ё ¬ ббЁў®ў бЇҐжЁ «м­л¬ ®Ўа §®¬.
€¬п ¬ ббЁў  "a" ¤«п

int a[5];

пў«пҐвбп ­  б ¬®¬ ¤Ґ«Ґ гЄ § вҐ«Ґ¬ ­  ҐЈ® ­г«Ґў®© н«Ґ¬Ґ­в.

’® Ґбвм г ­ б Ґбвм ЇҐаҐ¬Ґ­­лҐ (пйЁЄЁ)
б Ё¬Ґ­ ¬Ё

a[0] a[1] ... a[4].

ЏаЁ н⮬ б ¬® Ё¬п a ЇаЁ ҐЈ® ЁбЇ®«м§®ў ­ЁЁ ў Їа®Ја ¬¬Ґ ®§­ з Ґв &a[0]

a
|
|
|
V
a[0] a[1] a[2] a[3] a[4]
_________________________________________
| | | |