diff options
Diffstat (limited to 'uk-ua')
| -rw-r--r-- | uk-ua/c-ua.html.markdown | 860 |
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) |