[c/uk-ua] Add ukrainian translation for Clang (#3762)

* [c/uk-ua] Add ukrainian translation for Clang

* Apply suggestions from code review

Co-authored-by: Andre Polykanine <ap@oire.me>

1 files changed, 860 insertions, 0 deletions

diff --git a/uk-ua/c-ua.html.markdown b/uk-ua/c-ua.html.markdown
new file mode 100644
index 00000000..c4dac75f
--- /dev/null
+++ b/uk-ua/c-ua.html.markdown
@@ -0,0 +1,860 @@
+---
+language: c
+filename: learnc-ua.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
+    - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
+    - ["Marco Scannadinari", "https://marcoms.github.io"]
+    - ["Zachary Ferguson", "https://github.io/zfergus2"]
+    - ["himanshu", "https://github.com/himanshu81494"]
+    - ["Joshua Li", "https://github.com/JoshuaRLi"]
+    - ["Dragos B. Chirila", "https://github.com/dchirila"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+О, C! Досі мова для сучасних обчислень у високопродуктивних продуктах.
+
+C це імовірно найбільш низькорівнева мова, яку будуть використовувати більшість програмістів. Проте, вона компенсує це не тільки швидкістю виконання. Як тільки ви оціните її можливість ручного управління пам'яттю, С зможе відвести саме в ті місця, в які вам потрібно було потрапити.
+
+> **Дещо про прапори компілятора**
+>
+> За замовчуванням, gcc та clang досить тихо інформують про попередження та помилки
+> при компіляції, хоч це і може бути дуже корисною інформацією. Тому рекомендується
+> використовувати більш вимогливий компілятор. Ось кілька рекомендацій:
+>
+> `-Wall -Wextra -Werror -O2 -std=c99 -pedantic`
+>
+> За інформацією про ці та інші прапори зверніться до головної сторінки man вашого 
+> компілятора C (наприклад, `man 1 gcc`) або ж просто заґуґліть.
+
+
+```c
+// Однорядкові коментарі починаються з //
+// Проте вони з'явились тільки після С99.
+
+/*
+Багаторядкові коментарі мають такий вигляд. І працюють в C89.
+*/
+
+/*
+Багаторядкові коментарі не можуть вкладатись один в одний. 
+/* Будьте обережними */ // коментар закінчується на цьому рядку...
+*/ // ...а не на цьому!
+
+// Константа: #define <keyword>
+// Назви констант, як правило, пишуться великими літерами, проте це не вимога
+#define DAYS_IN_YEAR 365
+
+// Ще одним способом оголосити константи є перелічення констант.
+// До речі, всі вирази мають закінчуватись крапкою з комою.
+enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
+// MON отримає значення 2 автоматично, TUE дорівнюватиме 3 і т.д.
+
+// Імпортувати заголовки можна за допомогою #include
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// (Заголовки із стандартної бібліотеки С вказуються між <кутовими дужками>.)
+// Щоб додати власні заголовки, потрібно використовувати "подвійні лапки" 
+// замість кутових:
+//#include "my_header.h"
+
+// Сигнатури функцій попередньо оголошуються в .h файлах або на початку .с файлів.
+void function_1();
+int function_2(void);
+
+// Потрібно оголосити 'прототип функції' перед main(), реалізація функцій 
+// відбувається після функції main().
+int add_two_ints(int x1, int x2); // прототип функції
+// Варіант `int add_two_ints(int, int);` теж правильний (не потрібно називати 
+// аргументи). Рекомендується також називати аргументи в прототипі для 
+// кращого розуміння.
+
+// Вхідною точкою програми є функція під назвою main. Вона повертає чисельний тип.
+int main(void) {
+  // реалізація програми
+}
+
+// Аргументи командного рядка, вказані при запуску програми, також передаються
+// у функцію main.
+// argc - це кількість переданих аргументів
+// argv — це масив масивів символів, що містить самі аргументи
+// argv[0] - назва програми, argv[1] - перший аргумент, і т.д.
+int main (int argc, char** argv)
+{
+  // printf дозволяє вивести на екран значення, вивід - це форматований рядок, 
+  // в даному випадку %d позначає чисельне значення, \n — це новий рядок
+  printf("%d\n", 0); // => Виводить 0
+
+  ///////////////////////////////////////
+  // Типи
+  ///////////////////////////////////////
+
+  // Всі змінні повинні бути оголошені на початку поточного блоку області видимості.
+  // В цьому коді вони оголошуються динамічно. С99-сумісні компілятори
+  // дозволяють оголошення близько до місця, де значення використовується.
+
+  // int (цілочисельний знаковий тип) зазвичай займає 4 байти
+  int x_int = 0;
+
+  // short (цілочисельний знаковий тип) зазвичай займає 2 байти
+  // 
+  short x_short = 0;
+
+  // Символьний тип char гарантовано займає 1 байт
+  char x_char = 0;
+  char y_char = 'y'; // Символьні літерали позначаються ''
+
+  // long (цілочисельний знаковий тип) має розмір від 4 до 8 байтів; великі значення  
+  // типу long гарантовано займають 8 байтів
+  long x_long = 0;
+  long long x_long_long = 0;
+
+  // Тип float - це зазвичай 32-бітове число з плаваючою крапкою
+  float x_float = 0.0f; // Суфікс 'f' позначає літерал з плаваючою крапкою
+
+  // Тип double - це зазвийчай 64-бітове число з плаваючою крапкою
+  double x_double = 0.0; // дійсне число без суфіксів має тип double
+
+  // Цілочисельні типи можуть не мати знаку (бути більше, або ж рівними нулю)
+  unsigned short ux_short;
+  unsigned int ux_int;
+  unsigned long long ux_long_long;
+
+  // Char всередині одинарних лапок інтерпретуються як числа в наборі 
+  // символів комп'ютера.
+  '0'; // => 48 в таблиці ASCII.
+  'A'; // => 65 в таблиці ASCII.
+
+  // sizeof(T) повертає розмір змінної типу Т в байтах
+  // sizeof(obj) віддає розмір виразу (змінна, літерал, і т.п.)
+  printf("%zu\n", sizeof(int)); // => 4 (на більшості пристроїв з 4-байтним словом)
+
+  // Якщо аргумент оператора `sizeof` — це вираз, тоді його аргументи не оцінюються
+  // (крім масивів, розмір яких залежить від змінної).
+  // Значення, що повертається в цьому випадку, - це константа часу компіляції.
+  int a = 1;
+  // size_t - беззнаковий чисельний тип розміром щонайменше 2 байти, який
+  // використовується для відображення розміру об'єкта.
+  size_t size = sizeof(a++); // a++ не оцінюється
+  printf("sizeof(a++) = %zu where a = %d\n", size, a);
+  // Виводить "sizeof(a++) = 4 where a = 1" (на 32-бітній архітектурі)
+
+  // Масиви повинні бути проініціалізовані з конкретним розміром.
+  char my_char_array[20]; // Цей масив займає 1 * 20 = 20 байтів
+  int my_int_array[20]; // Цей масив займає 4 * 20 = 80 байтів
+  // (припускаючи 4-байтні числа)
+
+  // Таким чином можна проініціалізувати масив нулем:
+  char my_array[20] = {0};
+  // де "{0}" називається "ініціалізатором масиву".
+  
+  // Зазначте, можна явно не оголошувати розмір масиву, ЯКЩО ви проініціалізуєте 
+  // масив у тому ж рядку. Тому, наступне оголошення еквівалентне:
+  char my_array[] = {0};
+  // АЛЕ, потрібно визначити розмір масиву під час виконання, як тут:
+  size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
+  
+  // ПОПЕРЕДЖЕННЯ якщо ви вирішили використовувати даний підхід, потрібно 
+  // визначити розмір **перед тим**, як ви почнете передавати масив у функцію
+  // (побачите дискусію пізніше). Масиви перетворюються на вказівники при
+  // передачі як аргументи у функцію, тому попереднє твердження буде видавати
+  // хибний результат всередині функції.
+
+  // Індексація по масиву така ж сама, як і в інших мовах програмування або,
+  // скоріше, як у інших с-подібних мовах.
+  my_array[0]; // => 0
+
+  // Масиви незмінні, це просто частина пам'яті!
+  my_array[1] = 2;
+  printf("%d\n", my_array[1]); // => 2
+
+  // Масиви, розмір яких залежить від змінної, в С99 (та в С11 як вибірковий 
+  // функціонал) можуть бути оголошені також. Розмір такого масиву не має бути
+  // константою під час компіляції:
+  printf("Enter the array size: "); // спитати користувача розмір масиву
+  int array_size;
+  fscanf(stdin, "%d", &array_size);
+  int var_length_array[array_size]; // оголосити масив
+  printf("sizeof array = %zu\n", sizeof var_length_array);
+
+  // Приклад:
+  // > Enter the array size: 10
+  // > sizeof array = 40
+
+  // Рядки - це просто масиви символьних літералів (char), що закінчуються NULL 
+  // (0x00) байтом, представленим у рядках як спеціальний символ '\0'.
+  // (Не потрібно включати байт NULL в рядкові літерали; компілятор сам вставляє
+  // його наприкінці масиву.)
+  char a_string[20] = "This is a string";
+  printf("%s\n", a_string); // %s форматує рядок
+
+  printf("%d\n", a_string[16]); // => 0
+  // тобто, байт #17 - це 0 (так само, як і 18-ий, 19-ий, та 20-ий)
+
+  // Якщо між одинарними лапками є букви, тоді це символьний літерал.
+  // Він має тип `int`, а не `char` (так історично склалось).
+  int cha = 'a'; // добре
+  char chb = 'a'; // також добре (неявне перетворення з int на char)
+
+  // Багатовимірні масиви:
+  int multi_array[2][5] = {
+    {1, 2, 3, 4, 5},
+    {6, 7, 8, 9, 0}
+  };
+  // Доступ до елементів:
+  int array_int = multi_array[0][2]; // => 3
+
+  ///////////////////////////////////////
+  // Оператори
+  ///////////////////////////////////////
+
+  // Скорочення для багатьох оголошень:
+  int i1 = 1, i2 = 2;
+  float f1 = 1.0, f2 = 2.0;
+
+  int b, c;
+  b = c = 0;
+
+  // Арифметичні операції
+  i1 + i2; // => 3
+  i2 - i1; // => 1
+  i2 * i1; // => 2
+  i1 / i2; // => 0 (0.5 округлено до 0)
+
+  // Потрібно перетворити хоча б одну з цілочисельних змінних на float, щоб 
+  // отримати результат з плаваючою крапкою
+  (float)i1 / i2; // => 0.5f
+  i1 / (double)i2; // => 0.5 // Так само і для типу double
+  f1 / f2; // => 0.5, з певною точністю
+  // Такі обчислення не є точними
+
+  // Ділення за модулем також є
+  11 % 3; // => 2, остача від ділення
+
+  // Оператори порівняння ймовірно схожі, проте в С немає логічного типу.
+  // Натомість використовується int.
+  // (Або _Bool або bool в C99.)
+  // 0 - хибно (false), всі інші значення - правда (true). Оператори
+  // порівняння завжди повертають 0 або 1.
+  3 == 2; // => 0 (false)
+  3 != 2; // => 1 (true)
+  3 > 2; // => 1
+  3 < 2; // => 0
+  2 <= 2; // => 1
+  2 >= 2; // => 1
+
+  // C - це не Python, порівняння не утворюють ланцюги.
+  // Попередження: Рядок нижче скомпілюється, але він означає `(0 < a) < 2`.
+  // В даному випадку, це 1, тому що (0 < 1).
+  int between_0_and_2 = 0 < a < 2;
+  // Натомість потрібно використати:
+  int between_0_and_2 = 0 < a && a < 2;
+
+  // Логічні оператори з числами
+  !3; // => 0 (Логічне НЕ)
+  !0; // => 1
+  1 && 1; // => 1 (Логічне І)
+  0 && 1; // => 0
+  0 || 1; // => 1 (Логічне АБО)
+  0 || 0; // => 0
+
+  // Тернарний вираз з умовою ( ? : )
+  int e = 5;
+  int f = 10;
+  int z;
+  z = (e > f) ? e : f; // => 10 "if e > f return e, else return f."
+
+  // Оператори збільшення та зменшення на 1:
+  int j = 0;
+  int s = j++; // Повернути j ПОТІМ збільшити j. (s = 0, j = 1)
+  s = ++j; // Збільшити j ПОТІМ повернути j. (s = 2, j = 2)
+  // так само і для j-- та --j
+
+  // Побітові операції!
+  ~0x0F; // => 0xFFFFFFF0 (побітове заперечення, "перше доповнення", результат 
+  // для 32-бітного int)
+  0x0F & 0xF0; // => 0x00 (побітове І)
+  0x0F | 0xF0; // => 0xFF (побітове АБО)
+  0x04 ^ 0x0F; // => 0x0B (побітове XOR)
+  0x01 << 1; // => 0x02 (побітовий зсув вліво (на 1))
+  0x02 >> 1; // => 0x01 (побітовий зсув вправо (на 1))
+
+  // Будьте обережними при зсуві цілочисельних значень зі знаком.  
+  // Наступні дії дають невизначений результат:
+  // - зсув на біт, що зберігає знак числа (int a = 1 << 31)
+  // - зсув вліво на від'ємне число (int a = -1 << 2)
+  // - зсув на число, що більше за ширину типу 
+  // TODO: LHS
+  // - зсув на зміщення, що >= ширині типу в лівій частині виразу:
+  //   int a = 1 << 32; // Невизначена поведінка, якщо ширина int 32 біти.
+
+  ///////////////////////////////////////
+  // Структури розгалуження
+  ///////////////////////////////////////
+
+  // Оператор умови
+  if (0) {
+    printf("I am never run\n"); // ніколи не буде виконано
+  } else if (0) {
+    printf("I am also never run\n"); // теж ніколи не буде виконано
+  } else {
+    printf("I print\n");	// це буде надруковано
+  }
+
+  // Цикл з передумовою
+  int ii = 0;
+  while (ii < 10) { // БУДЬ-ЯКЕ значення, що менше 10 - правда.
+    printf("%d, ", ii++); // ii++ збільшує ii на 1 ПІСЛЯ передачі поточного значення.
+  } // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // Цикл з післяумовою
+  int kk = 0;
+  do {
+    printf("%d, ", kk);
+  } while (++kk < 10); // ++kk збільшує kk на 1 ПЕРЕД передачою поточного значення.
+  // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // Цикл з лічильником
+  int jj;
+  for (jj=0; jj < 10; jj++) {
+    printf("%d, ", jj);
+  } // => виводить "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // *****Додатково*****:
+  // Цикли та функції обов'язково повинні мати тіло. Якщо тіло не потрібно:
+  int i;
+  for (i = 0; i <= 5; i++) {
+    ; // використовуйте крапку з комою, щоб симулювати тіло (пусте твердження)
+  }
+  // Або
+  for (i = 0; i <= 5; i++);
+
+  // Розгалуження з множинним вибором: switch()
+  switch (a) {
+  case 0: // значення повинні бути *константними* виразами і мати вбудований тип
+          //(наприклад, перелічення)
+    printf("Hey, 'a' equals 0!\n");
+    break; // якщо не використати break, то управління буде передано наступному блоку
+  case 1:
+    printf("Huh, 'a' equals 1!\n");
+    break;
+    // Будьте обережними, виконання продовжиться до тих пір, поки
+    // не зустрінеться наступний "break".
+  case 3:
+  case 4:
+    printf("Look at that.. 'a' is either 3, or 4\n");
+    break;
+  default:
+    // якщо вираз a не співпадає з описаними значеннями, то виконується 
+    // блок default
+    fputs("Error!\n", stderr);
+    exit(-1);
+    break;
+  }
+  /*
+  Використання "goto" в С
+  */
+  typedef enum { false, true } bool;
+  // вводимо таке перелічення, оскільки С не має логічного типу до С99
+  bool disaster = false;
+  int i, j;
+  for(i=0;i<100;++i)
+  for(j=0;j<100;++j)
+  {
+    if((i + j) >= 150)
+        disaster = true;
+    if(disaster)
+        goto error;
+  }
+  error :
+  printf("Error occurred at i = %d & j = %d.\n", i, j);
+  /*
+  https://ideone.com/GuPhd6
+  Даний приклад виведе "Error occurred at i = 51 & j = 99."
+  */
+
+  ///////////////////////////////////////
+  // Приведення до типів
+  ///////////////////////////////////////
+
+  // Кожне значенння в С має тип, але можна перевести значення з одного типу в 
+  // інший, якщо потрібно (із деякими обмеженнями).
+
+  int x_hex = 0x01; // Змінним можна присвоювати літерали в шістнадцятковій 
+                    // системі числення
+
+  // Приведення до типу призведе до спроби зберегти чисельне значення
+  printf("%d\n", x_hex); // => Виводить 1
+  printf("%d\n", (short) x_hex); // => Виводить 1
+  printf("%d\n", (char) x_hex); // => Виводить 1
+
+  // В данному випадку попередження не виникатиме, якщо значення виходить за межі 
+  // значення типу
+  printf("%d\n", (unsigned char) 257); // => 1 (максимальне значення char = 255, 
+  // якщо char має довжину 8 біт)
+
+  // Для того, щоб дізнатись максимальний розмір `char`, `signed char` або ж 
+  // `unsigned char`, потрібно використати макроси CHAR_MAX, SCHAR_MAX та UCHAR_MAX
+  // відповідно з <limits.h>. 
+
+  // Вбудовані типи можуть бути приведені до типу із плаваючою крапкою і навпаки.
+  printf("%f\n", (double) 100); // %f завжди перетворює число на double...
+  printf("%f\n", (float)  100); // ...навіть, якщо це float.
+  printf("%d\n", (char)100.0);
+
+  ///////////////////////////////////////
+  // Вказівники
+  ///////////////////////////////////////
+
+  // Вказівник - це змінна, що зберігає адресу у пам'яті. Оголошення вказівника 
+  // також потребує інформації про тип об'єкта, на який він вказує. Можна 
+  // отримати адресу пам'яті будь-якої змінної, а потім працювати з нею.
+
+  int x = 0;
+  printf("%p\n", (void *)&x); // Оператор & повертає адресу змінної у пам'яті
+  // (%p форматує об'єкт вказівника типу void *)
+  // => Виводить деяку адресу в пам'яті
+
+  // Для оголошення вказівника потрібно поставити * перед його назвою.
+  int *px, not_a_pointer; // px - це вказівник на цілочисельне значення (int)
+  px = &x; // Зберігає адресу змінної x в px
+  printf("%p\n", (void *)px); // => Виводить адресу в пам'яті
+  printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer));
+  // => Виводить "8, 4" на звичайній 64-бітній системі
+
+  // Щоб прочитати значення, яке зберігається за адресою, на яку вказує вказівник,
+  // потрібно поставити знак * перед назвою змінної. 
+  // Так, * використовується одночасно і для оголошення вказівника, і для отримання 
+  // значення за адресою. Звучить заплутано, проте тільки спочатку.
+  printf("%d\n", *px); // => Виводить 0, значення x
+
+  // Можна також змінити значення, на яке посилається вказівник.
+  // Тут звернення до адреси обернене у круглі дужки, тому що 
+  // ++ має вищий пріоритет виконання, ніж *.
+  (*px)++; // Збільшити значення, на яке вказує px, на 1
+  printf("%d\n", *px); // => Виводить 1
+  printf("%d\n", x); // => Виводить 1
+
+  // Масиви зручно використовувати для виділення неперервного блоку пам'яті.
+  int x_array[20]; // оголошує масив з 20 елементів (розмір можна задати лише один раз)
+  int xx;
+  for (xx = 0; xx < 20; xx++) {
+    x_array[xx] = 20 - xx;
+  } // Ініціалізує x_array значеннями 20, 19, 18,... 2, 1
+
+  // Оголосити вказівник типу int, який посилається на масив x_array
+  int* x_ptr = x_array;
+  // x_ptr тепер вказує на перший елемент масиву (число 20).
+  //  
+  // Це працює, тому що при зверненні до імені масиву повертається вказівник 
+  // на перший елемент. Наприклад, коли масив передається у функцію або присвоюється
+  // вказівнику, він неявно приводиться до вказівника.
+  // Виключення: 
+  // - коли вказівник передається як аргумент із оператором `&`:
+  int arr[10];
+  int (*ptr_to_arr)[10] = &arr; // &arr НЕ має тип `int *`!
+  // Він має тип "вказівник на масив" (з 10 чисел).
+  // - коли масив - це рядковий літерал, що використовується для ініціалізації
+  // масив символів:
+  char otherarr[] = "foobarbazquirk";
+  // - коли масив - це аргумент операторів `sizeof` або `alignof`:
+  int arraythethird[10];
+  int *ptr = arraythethird; // те ж саме, що з int *ptr = &arr[0];
+  printf("%zu, %zu\n", sizeof(arraythethird), sizeof(ptr));
+  // Ймовірно, виводить "40, 4" або "40, 8"
+
+  // Інкрементація та декрементація вказівника залежить від його типу.
+  // (так звана арифметика вказівників)
+  printf("%d\n", *(x_ptr + 1)); // => Виводить 19
+  printf("%d\n", x_array[1]); // => Виводить 19
+
+  // Можна також динамічно виділити послідовні блоки в пам'яті за допомогою
+  // функції malloc зі стандартної бібліотеки. malloc приймає один аргумент типу
+  // size_t, що описує кількість байтів для виділення (зазвичай із купи, проте це
+  // може бути неправдою на вбудованих системах - стандарт С нічого про це не повідомляє).
+  int *my_ptr = malloc(sizeof(*my_ptr) * 20);
+  for (xx = 0; xx < 20; xx++) {
+    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
+  } // Проініціалізувати пам'ять значеннями 20, 19, 18, 17... 2, 1 (як int)
+
+  // Будьте обережними із передачею значень, що надаються користувачем, в malloc!
+  // Про всяк випадок, використовуйте calloc в таких ситуаціях (який, на відміну від 
+  // malloc, також заповнює пам'ять нулями).
+  int* my_other_ptr = calloc(20, sizeof(int));
+
+  // Немає стандартного способу визначити розмір динамічно виділеного масиву в С.
+  // Через це, якщо масиви будуть часто передаватись в програмі, потрібна інша змінна,
+  // яка буде відслідковувати кількість елементів в масиві. Детальніше в розділі 
+  // про функції.
+  size_t size = 10;
+  int *my_arr = calloc(size, sizeof(int));
+  // Додати елемент до масиву.
+  size++;
+  my_arr = realloc(my_arr, sizeof(int) * size);
+  if (my_arr == NULL) {
+    // Не забувайте перевіряти результат виконання realloc на помилки!
+    return
+  }
+  my_arr[10] = 5;
+
+  // Робота з вказівниками може призводити до неочікуваних і непрогнозованих 
+  // результатів, якщо звернутись до пам'яті, що не була виділена вами.
+  printf("%d\n", *(my_ptr + 21)); // => Хто зна, що буде виведено. 
+  									// Може навіть вилетіти з помилкою.
+
+  // Після закінчення роботи із виділеною за допомогою malloc пам'яттю, її обов'язково
+  // потрібно звільнити. Інакше ніхто не зможе нею скористатися, аж поки програма не
+  // завершить свою роботу (така ситуація називається "витоком пам'яті").
+  free(my_ptr);
+
+  // Рядки - це масиви символів, проте вони найчастіше представлені як 
+  // вказівник на символ (тобто, вказівник на перший елемент масиву). Вважається
+  // хорошим підходом використовувати `const char *', посилаючись на об'єкт
+  // рядка, оскільки його не можна змінити ("foo"[0] = 'a' ЗАБОРОНЕНО).
+  const char *my_str = "This is my very own string literal";
+  printf("%c\n", *my_str); // => 'T'
+
+  // Це не працюватиме, якщо рядок - це масив (потенційно створений за допомогою 
+  // рядкового літерала), що зберігається у частині пам'яті, яку можна перезаписувати:
+  char foo[] = "foo";
+  foo[0] = 'a'; // Дозволяється, foo тепер містить "aoo"
+
+  function_1();
+} // Кінець функції main
+
+///////////////////////////////////////
+// Функції
+///////////////////////////////////////
+
+// Синтаксис оголошення функції:
+// <тип повернення> <назва функції>(<аргументи>)
+
+int add_two_ints(int x1, int x2)
+{
+  return x1 + x2; // Використовуйте return, щоб повернути значення
+}
+
+/*
+Дані у функцію передають за значенням. Коли функція викликається, аргументи, що
+передаються у функцію, копіюються з оригіналів (окрім масивів). Всі зміни над 
+значенням аргументів всередині функції не впливають на значення оригіналів.
+
+Використовуйте вказівники, якщо потрібно редагувати безпосередньо оригінальні 
+значення аргументів.
+
+Приклад: замінити рядок на обернений.
+*/
+
+// void означає, що функція нічого не повертає
+void str_reverse(char *str_in)
+{
+  char tmp;
+  size_t ii = 0;
+  size_t len = strlen(str_in); // `strlen()` це частина стандартної бібліотеки С
+                               // Зауважте: довжина, яку повертає `strlen`, не включає
+                               //           термінальний NULL байт ('\0')
+  for (ii = 0; ii < len / 2; ii++) { // в C99 можна напряму оголошувати тип `ii` в циклі
+    tmp = str_in[ii];
+    str_in[ii] = str_in[len - ii - 1]; // ii-й символ з кінця
+    str_in[len - ii - 1] = tmp;
+  }
+}
+// Зауважте: для використання strlen() потрібно завантажити файл заголовку string.h
+
+/*
+char c[] = "This is a test.";
+str_reverse(c);
+printf("%s\n", c); // => ".tset a si sihT"
+*/
+/*
+Оскільки можна повертати тільки одну змінну, для зміни значення більшої 
+кількості змінних можна використовувати виклик за посиланням
+*/
+void swapTwoNumbers(int *a, int *b)
+{
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+/*
+int first = 10;
+int second = 20;
+printf("first: %d\nsecond: %d\n", first, second);
+swapTwoNumbers(&first, &second);
+printf("first: %d\nsecond: %d\n", first, second);
+// змінні обмінюються значеннями
+*/
+
+/*
+Масиви завжди передаються у функції як вказівники, не зважаючи на тип масиву 
+(статичний чи динамічний). Тому всередині функція не знає про розмір масиву.
+*/
+// Розмір масиву завжди має передаватись разом із масивом!
+void printIntArray(int *arr, size_t size) {
+    int i;
+    for (i = 0; i < size; i++) {
+        printf("arr[%d] is: %d\n", i, arr[i]);
+    }
+}
+/*
+int my_arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+int size = 10;
+printIntArray(my_arr, size);
+// виведе "arr[0] is: 1" і т.д.
+*/
+
+// Ключове слово extern використовується, якщо всередині функції потрібно звернутись
+// до змінної, що була оголошена поза функцією.
+int i = 0;
+void testFunc() {
+  extern int i; // використовуємо зовнішню змінну i
+}
+
+// Зробити зовнішню змінну приватною у вихідному файлі за допомогою static:
+static int j = 0; // інші файли, що використовують testFunc2(), 
+                  // не матимуть доступу до змінної j
+void testFunc2() {
+  extern int j;
+}
+// Ключове слово static робить змінну недоступною для коду поза даною одиницею 
+// компіляції. (На більшості систем, одиниця компіляції - це файл). 
+// static можна використовувати до глобальних змінних, функцій, локальних
+// змінних у функціях. Локальні змінні, проініціалізовані static, поводять
+// себе як глобальні змінні, проте тільки в межах даного файлу. Статичні
+// змінні ініціалізуються 0, якщо інше значення не було вказане.
+// **Як варіант, функції можна зробити приватними оголосивши їх як static**
+
+///////////////////////////////////////
+// Користувацькі типи та структури
+///////////////////////////////////////
+
+// Ключове слово typedef використовується, щоб створити псевдонім типу
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Структури - це такі собі колекції з даними. Пам'ять для полів виділяється 
+// послідовно, в порядку їх написання:
+struct rectangle {
+  int width;
+  int height;
+};
+
+// Проте це не означає, що 
+// sizeof(struct rectangle) == sizeof(int) + sizeof(int)
+// в зв'язку з вирівнюванням пам'яті [1]
+
+void function_1()
+{
+  struct rectangle my_rec;
+
+  // Доступ до полів структури відбувається через .
+  my_rec.width = 10;
+  my_rec.height = 20;
+
+  // Можна створити вказівники на структуру
+  struct rectangle *my_rec_ptr = &my_rec;
+
+  // Звернення до структури через вказівник та зміна значень поля:
+  (*my_rec_ptr).width = 30;
+
+  // Але є й альтернативний спосіб звернутись до поля через вказівник, використовуючи 
+  // оператор -> (краще читається)
+  my_rec_ptr->height = 10; // Те ж саме, що (*my_rec_ptr).height = 10;
+}
+
+// Можна використати typedef перед struct
+typedef struct rectangle rect;
+
+int area(rect r)
+{
+  return r.width * r.height;
+}
+
+// Якщо ваша структура доволі громіздка, можна звертатись до неї через вказівник, 
+// щоб уникнути копіювання всієї структури:
+int areaptr(const rect *r)
+{
+  return r->width * r->height;
+}
+
+///////////////////////////////////////
+// Вказівники на функції
+///////////////////////////////////////
+/*
+Під час виконання функції знаходяться за відомими адресами в пам'яті. Вказівники 
+на функції - це ті ж самі вказівники, що зберігають адресу у пам'яті, проте можуть
+використовуватись, щоб викликати функції напряму і передавати обробники (або функції зі 
+зворотнім зв'язком). Хоча, синтаксис спочатку може бути доволі незрозумілим.
+
+Приклад: use str_reverse from a pointer
+*/
+void str_reverse_through_pointer(char *str_in) {
+  // Оголосити вказівник на функцію під назвою f.
+  void (*f)(char *); // Сигнатура повинна точно співпадати із цільовою функцією.
+  f = &str_reverse; // Присвойте адресу певної функції (визначається під час виконання)
+  // f = str_reverse; повинно працювати також
+  (*f)(str_in); // Виклик функції через вказівник
+  // f(str_in); // Це альтернативний, але теж вірний синтаксис виклику функції.
+}
+
+/*
+Якщо сигнатури функцій співпадають, можна присвоїти будь-яку функцію тому ж 
+самому вказівнику. Вказівники на функції зазвичай використовуються як псевдоніми 
+для спрощення та покращення читабельності коду. Приклад:
+*/
+
+typedef void (*my_fnp_type)(char *);
+
+// Використання при оголошенні змінної вказівника:
+// ...
+// my_fnp_type f;
+
+
+// Спеціальні символи:
+/*
+'\a'; // символ попередження (дзвінок)
+'\n'; // символ нового рядка
+'\t'; // символ табуляції (вирівнювання по лівому краю)
+'\v'; // вертикальна табуляція
+'\f'; // нова сторінка
+'\r'; // повернення каретки
+'\b'; // стирання останнього символу
+'\0'; // нульовий символ. Зазвичай розташовується в кінці рядка.
+//   hello\n\0. \0 використовується для позначення кінця рядка.
+'\\'; // зворотній слеш
+'\?'; // знак питання
+'\''; // одинарні лапки
+'\"'; // подвійні лапки
+'\xhh'; // шістнадцяткове число. Наприклад: '\xb' = символ вертикальної табуляції
+'\0oo'; // вісімкове число. Наприклад: '\013' = символ вертикальної табуляції
+
+// форматування виводу:
+"%d";    // ціле число (int)
+"%3d";   // ціле число, щонайменше 3 символи (вирівнювання по правому краю)
+"%s";    // рядок
+"%f";    // число з плаваючою крапкою (float)
+"%ld";   // велике ціле число (long)
+"%3.2f"; // число з плаваючою крапкою, щонайменше 3 цифри зліва і 2 цифри справа 
+"%7.4s"; // (аналогічно для рядків)
+"%c";    // символ
+"%p";    // вказівник. Зазначте: потребує перетворення типу на (void *) перед 
+         //                      використанням у `printf`.
+"%x";    // шістнадцяткове число
+"%o";    // вісімкове число
+"%%";    // друкує %
+*/
+
+///////////////////////////////////////
+// Порядок виконання
+///////////////////////////////////////
+
+//---------------------------------------------------//
+//        Оператори                  | Асоціативність//
+//---------------------------------------------------//
+// () [] -> .                        | зліва направо //
+// ! ~ ++ -- + = *(type)sizeof       | справа наліво //
+// * / %                             | зліва направо //
+// + -                               | зліва направо //
+// << >>                             | зліва направо //
+// < <= > >=                         | зліва направо //
+// == !=                             | зліва направо //
+// &                                 | зліва направо //
+// ^                                 | зліва направо //
+// |                                 | зліва направо //
+// &&                                | зліва направо //
+// ||                                | зліва направо //
+// ?:                                | справа наліво //
+// = += -= *= /= %= &= ^= |= <<= >>= | справа наліво //
+// ,                                 | зліва направо //
+//---------------------------------------------------//
+
+/****************************** Файли заголовків *********************************
+
+Файли заголовків важливі в С. Вони розділяють вихідний код та визначення на різні 
+файли, що робить їх кращими для розуміння. 
+
+Файли заголовків синтаксично подібні до вихідних файлів С, проте описуються у".h"
+файлах. Їх можна додати в код за допомогою директиви #include "example.h", якщо
+example.h існує в тому ж каталозі, що і файл С.
+*/
+
+/* 
+Так можна запобігти тому, що заголовок буде оголошений кілька разів. Така ситуація
+виникає у випадку циклічної залежності, тобто коли вміст заголовку вже було
+оголошено.                                                         
+*/
+#ifndef EXAMPLE_H /* якщо EXAMPLE_H ще не оголошено. */
+#define EXAMPLE_H /* Визначити макрос EXAMPLE_H. */
+
+/* 
+Заголовки можна додавати в інші заголовки, таким чином вони разом додаються
+у подальшому.                      
+*/
+#include <string.h>
+
+/* 
+Макроси можуть бути визначені також у заголовку та використовуватись у файлах,
+що містять цей заголовок. 
+*/
+#define EXAMPLE_NAME "Dennis Ritchie"
+
+/* Макроси функції також можна визначити.  */
+#define ADD(a, b) ((a) + (b))
+/*
+Зверніть увагу на круглі дужки навколо аргументів! Важливо переконатись, що 
+a та b не можна проінтерпретувати інакше. Наприклад:
+MUL(x, y) (x * y); 
+MUL(1 + 2, 3) -> (1 + 2 * 3), що є помилкою
+*/
+
+/* Struct та typedef можуть використовуватись для узгодженості між файлами. */
+typedef struct Node
+{
+    int val;
+    struct Node *next;
+} Node;
+
+/* Так само і перелічення. */
+enum traffic_light_state {GREEN, YELLOW, RED};
+
+/* 
+Прототипи функцій також можна оголосити так, щоб використовувати у кількох 
+файлах. Але так робити не варто. Краще оголосити їх у С файлі.
+*/
+Node createLinkedList(int *vals, int len);
+
+/*
+Окрім вище згаданих випадків, всі інші визначення мають описуватись у С файлах.
+*/
+
+#endif /* Кінець директиви передкомпіляції if. */
+
+```
+## Додаткові матеріали
+
+Кращим посібником для вивчення С буде книга авторства Деніса Рітчі (творець С) та Браяна Кернігана, 
+[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
+Але обережно з нею, книга старезна і містить неточності (ідеї, що вже вважаються не надто прийнятними).
+
+Ще одним хорошим ресурсом є книга "Learn C The Hard Way" (наявна тільки англійською).
+
+На деякі часті запитання дасть відповідь англомовний ресурс [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+Нагадаю, що важливо використовувати правильні інтервали, відступи та загалом мати узгоджений стиль коду.
+Зручний для читання код краще, ніж складний код або зроблений нашвидкоруч. За прикладом можна звернутись до
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/process/coding-style.rst).
+
+Щодо всього іншого, Ґуґл на допомогу!
+
+[1] [Чому розмір структури не дорівнює сумі розмірів її полів? (англ.)](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member)