mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-28 03:38:51 +00:00
861 lines
46 KiB
C
861 lines
46 KiB
C
---
|
||
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)
|