Оператори, перетворення типів та логічні операції

Мова операторів: від виразів до рішень

До цього моменту ви вже вмієте зберігати дані у змінних і вводити їх з клавіатури. Але програма — це не просто сховище даних. Програма думає: вона порівнює числа, приймає рішення, виконує дії залежно від умов. Інструментом для всього цього є оператори.

Оператор (operator) — це символ або ключове слово, яке дає компілятору команду виконати певну дію над одним або кількома операндами (operands). Операнди — це дані, з якими виконується операція: значення, змінні або вирази.

int result = 10 + 3;
//            ↑   ↑
//       операнди: 10 і 3
//              ↑
//       оператор: +

Усі оператори C++ поділяються на кілька груп за призначенням:

У цій статті ми детально розберемо перші п'ять груп — саме їх ви будете використовувати щодня.

Арифметичні оператори

Ви вже зустрічалися з ними у попередньому розділі. Розглянемо їх систематично та зверніть увагу на деталі, які часто є джерелом помилок.

Ціле ділення та його пастка

Найбільш несподіваний оператор для новачків — це /. У C++ поведінка оператора ділення залежить від типів операндів.

Якщо обидва операнди є цілими числами (int, short, long тощо), C++ виконує ціле ділення (integer division): дробова частина результату просто відкидається, а не округлюється.

int a = 7;
int b = 3;
int result = a / b;  // result = 2, а не 2.333...

Зверніть увагу на принципову відмінність: 7 / 3 = 2, а не 2.33. Дробова частина .33 не округлюється до нуля — вона знищується. Якщо вам потрібен дійсний результат, хоча б один із операндів повинен бути типу float або double:

int a = 7;
int b = 3;

double result1 = a / b;          // result1 = 2.0  ← НЕПРАВИЛЬНО!
double result2 = (double)a / b;  // result2 = 2.333... ← Правильно
double result3 = a / 3.0;        // result3 = 2.333... ← Теж правильно

У першому рядку ціле ділення відбувається до присвоєння в double: спочатку 7 / 3 = 2, а потім 2 конвертується у 2.0. Результат некоректний. У другому та третьому рядках хоча б один з операндів є дійсним числом — тому і ділення стає дійсним.

Оператор остачі %

Оператор % (модуль або остача від ділення) повертає залишок від цілого ділення. Він застосовується лише до цілих типів.

cout << 10 % 3;  // 1  (10 = 3*3 + 1)
cout << 14 % 7;  // 0  (14 = 7*2 + 0)
cout << 5  % 8;  // 5  (5 = 8*0 + 5)

Навіщо він потрібен? Декілька практичних застосувань:

• Перевірка парності: якщо n % 2 == 0, число парне.
• Циклічне лічення: наприклад, дні тижня від 0 до 6. Якщо день d + 3 може вийти за межі, використайте (d + 3) % 7.
• Виділення цифр: остання цифра числа n — це n % 10, передостання — (n / 10) % 10.

Пріоритет арифметичних операцій

C++ дотримується математичного пріоритету (precedence): множення, ділення та остача виконуються до додавання та віднімання. Для зміни порядку використовуйте дужки.

int a = 2 + 3 * 4;    // a = 14 (спочатку 3*4=12, потім 2+12)
int b = (2 + 3) * 4;  // b = 20 (дужки змінюють порядок)
int c = 10 - 6 / 2;   // c = 7  (спочатку 6/2=3, потім 10-3)

Оператори присвоєння

Звичайний оператор присвоєння = ви вже знаєте. Але C++ має скорочені форми, які суміщають арифметичну операцію з присвоєнням. Вони називаються складеними операторами присвоєння (compound assignment operators).

Складені оператори присвоєння

int score = 100;
score += 50;  // score = 150 (нараховуємо бонуси)
score -= 30;  // score = 120 (штраф)
score *= 2;   // score = 240 (подвоєння)
score /= 3;   // score = 80  (ціле ділення!)

Ці оператори не просто «зручне скорочення» — вони роблять код читабельнішим, явно показуючи, що ми модифікуємо існуючу змінну, а не присвоюємо їй нове незалежне значення.

Інкремент та декремент

Окремий та дуже поширений випадок — збільшення або зменшення значення рівно на одиницю. Для цього C++ має спеціальні оператори.

Інкремент (increment) ++ — збільшує значення змінної на 1. Декремент (decrement) -- — зменшує значення змінної на 1.

int counter = 0;
counter++;  // counter = 1
counter++;  // counter = 2
counter--;  // counter = 1

Кожен з цих операторів існує у двох формах: префіксній (перед змінною) та постфіксній (після змінної). Різниця проявляється лише тоді, коли вираз використовується у ширшому контексті — наприклад, при виводі або присвоєнні.

int x = 5;
int y = ++x;  // Спочатку x стає 6, потім y = 6
// x = 6, y = 6

int x = 5;
int y = x++;  // y = 5 (береться поточне значення), потім x стає 6
// x = 6, y = 5

Перетворення типів

У C++ типи суворо визначені. Проте іноді нам потрібно «переключитися» між типами: взяти ціле число і зробити з нього дійсне, або навпаки. Для цього існують механізми перетворення типів (type conversion).

Неявне перетворення (implicit conversion)

Коли значення одного типу автоматично перетворюється в інший без жодних додаткових команд — це неявне перетворення. Компілятор виконує його самостійно, коли типи операндів не збігаються.

Загальне правило: при змішуванні різних числових типів C++ розширює менший тип до більшого (щоб уникнути втрати інформації).

int    age = 25;
double ratio = age;      // int → double: неявне розширення (безпечно)
// ratio = 25.0

double pi = 3.14159;
int piInt = pi;          // double → int: неявне звуження (небезпечно!)
// piInt = 3 (дробова частина ЗАГУБЛЕНА)

Ієрархія неявного розширення виглядає таким чином:

graph LR
    A["bool"] --> B["char"]
    B --> C["short"]
    C --> D["int"]
    D --> E["long"]
    E --> F["long long"]
    F --> G["float"]
    G --> H["double"]

    style A fill:#64748b,stroke:#334155,color:#ffffff
    style H fill:#3b82f6,stroke:#1d4ed8,color:#ffffff
    style D fill:#f59e0b,stroke:#b45309,color:#ffffff

Кожен тип автоматично й безпечно розширюється до наступного. Рух у зворотному напрямку (звуження) — небезпечний, адже веде до втрати даних.

Явне перетворення (explicit cast)

Коли перетворення потрібно виконати свідомо та навмисно, використовується явне приведення типу (type cast). Синтаксис у стилі C, який прийнятий у цьому курсі:

(тип) вираз

int a = 7;
int b = 3;

double result = (double)a / b;  // 7.0 / 3 = 2.333...

Тут (double)a — це явне перетворення значення змінної a до типу double. Сама змінна a при цьому не змінюється — вона залишається int. Перетворюється лише значення, яке використовується у цьому виразі.

Розглянемо ще один типовий приклад — виведення відсотка:

int correct = 7;
int total = 10;

// Неправильно: 7 / 10 = 0 (ціле ділення), 0 * 100 = 0
double percent1 = correct / total * 100;

// Правильно: (7.0) / 10 = 0.7, 0.7 * 100 = 70.0
double percent2 = (double)correct / total * 100;

cout << "Percent: " << percent2 << "%\n";  // Percent: 70%

Перетворення char та int

Тип char зберігає один символ, але внутрішньо він є числом — кодом символу за таблицею ASCII. Це дає змогу конвертувати між символами та їх числовими кодами.

char letter = 'A';
int code = (int)letter;     // code = 65 (код символу 'A' в ASCII)

int number = 66;
char symbol = (char)number; // symbol = 'B' (символ з кодом 66)

cout << "Код 'A': " << code << "\n";    // Код 'A': 65
cout << "Символ 66: " << symbol << "\n"; // Символ 66: B

Ця властивість використовується, наприклад, для визначення, чи є символ літерою, цифрою, або для переведення між регістрами:

char lower = 'a';
char upper = (char)(lower - 32);  // 'a'(97) - 32 = 'A'(65)
cout << upper;  // A

Оператори порівняння

Щоб програма могла приймати рішення, їй потрібно вміти порівнювати значення. Для цього використовуються оператори порівняння (relational / comparison operators). На відміну від арифметичних операторів, вони повертають не число, а логічне значення типу bool: true (істина) або false (хибність).

Де застосовуються оператори порівняння?

Результат порівняння — значення bool. Його можна зберегти у змінній:

int age = 20;
bool isAdult = (age >= 18);  // true
bool isChild = (age < 12);   // false

cout << isAdult;  // Виведе: 1 (true відображається як 1)
cout << isChild;  // Виведе: 0 (false відображається як 0)

Або використати напряму в умовній конструкції (детальніше про if — у наступному розділі):

if (age >= 18) {
    cout << "Доступ дозволено\n";
}

Логічні оператори

Поодинці оператори порівняння дозволяють перевірити лише одну умову: «вік більший за 18» або «пароль вірний». Але реальні програми часто потребують складніших перевірок: «вік більший за 18 І є квиток» або «температура вище 37 АБО є симптоми». Для об'єднання кількох умов в одну використовуються логічні оператори (logical operators).

Оператор І — && (логічне AND)

Повертає true лише якщо обидві умови є істинними одночасно. Достатньо хоч одній умові бути false — і весь вираз стає false.

Таблиця істинності &&:

int age = 20;
bool hasTicket = true;

bool canEnter = (age >= 18) && hasTicket;
// true && true → true: вхід дозволено

Аналогія з життя: ви заходите у клуб лише якщо І ви повнолітній, І у вас є квиток.

Оператор АБО — || (логічне OR)

Повертає true якщо хоча б одна з умов є істинною. Повертає false лише якщо обидві умови хибні.

Таблиця істинності ||:

bool hasPass = false;
bool isEmployee = true;

bool canGoIn = hasPass || isEmployee;
// false || true → true: вхід дозволено

Аналогія: Ви можете увійти у службовий вхід, якщо АБО маєте перепустку, АБО є співробітником (є хоча б одна підстава).

Оператор НЕ — ! (логічне NOT)

Інвертує логічне значення: перетворює true на false, і навпаки. Це унарний оператор — він діє на один операнд.

bool isRaining = false;
bool goForAWalk = !isRaining;  // true: не дощить → можна гуляти

bool isDividableBy2 = (number % 2 == 0);
bool isOdd = !isDividableBy2;  // інвертуємо: ділиться → підраховуємо непарне

Складні логічні вирази

Логічні оператори можна комбінувати для побудови складних умов. Пріоритет операцій: ! виконується першим, потім &&, потім ||. Дужки дозволяють перевизначити порядок.

int temperature = 38;
bool hasCough = true;
bool hasVaccine = false;

// Пацієнт у групі ризику: висока температура АБО (кашель І без щеплення)
bool isAtRisk = (temperature > 37) || (hasCough && !hasVaccine);
// true || (true && true) → true || true → true

Розберемо, як обчислюється цей вираз покроково:

1. !hasVaccine → !false → true
2. hasCough && true → true && true → true
3. (temperature > 37) → (38 > 37) → true
4. true || true → true

Пріоритет усіх операторів

У складних виразах порядок виконання операторів визначається їх пріоритетом (precedence). Ось спрощена таблиця від найвищого до найнижчого:

graph TD
    A["Вираз: a > 0 && b != 0 || !flag"] --> B["Крок 1: ! (NOT)"]
    B --> C["!flag → true/false"]
    C --> D["Крок 2: > і != (порівняння)"]
    D --> E["a > 0 → bool, b != 0 → bool"]
    E --> F["Крок 3: && (AND)"]
    F --> G["(a > 0) && (b != 0) → bool"]
    G --> H["Крок 4: || (OR)"]
    H --> I["... || !flag → фінальний bool"]

    style A fill:#3b82f6,stroke:#1d4ed8,color:#ffffff
    style I fill:#3b82f6,stroke:#1d4ed8,color:#ffffff
    style F fill:#f59e0b,stroke:#b45309,color:#ffffff
    style H fill:#64748b,stroke:#334155,color:#ffffff

Практичний приклад: Перевірка трикутника

Складемо програму, яка зчитує три сторони та перевіряє, чи можуть вони утворити трикутник. За теоремою: трикутник існує, якщо кожна зі сторін менша за суму двох інших.

#include <iostream>

using namespace std;

int main()
{
    double a, b, c;

    cout << "Enter three sides: ";
    cin >> a >> b >> c;

    bool isValid = (a + b > c) && (a + c > b) && (b + c > a);

    cout << "Is triangle: " << isValid << "\n";
    // Виведе 1 (true) або 0 (false)

    return 0;
}

Розберемо ключові елементи:

• Рядок 10: Зчитуємо три числа через пробіл — cin автоматично розбиває введення за пробілами.
• Рядок 12: Перевірка складається з трьох умов, з'єднаних &&. Усі три повинні бути true одночасно, щоб трикутник існував.
• Рядок 14: bool при виводі через cout відображається як 0 або 1.

Приклади роботи:

Enter three sides: 3 4 5
Is triangle: 1

Enter three sides: 1 2 10
Is triangle: 0

Практичний приклад: Конвертер одиниць з відсотком

Розробимо програму, що переводить температуру із Цельсія у Фаренгейт і відразу показує відсоток від «точки кипіння» (100°C = 212°F).

#include <iostream>

using namespace std;

int main()
{
    double celsius;

    cout << "Enter temperature in Celsius: ";
    cin >> celsius;

    // Формула перетворення
    double fahrenheit = celsius * 9.0 / 5.0 + 32.0;

    // Відсоток від точки кипіння (100 C)
    double percentOfBoiling = celsius / 100.0 * 100.0;

    // Чи перевищує температура поріг нормального тіла (36.6)?
    bool isHighTemp = celsius > 36.6;

    cout << celsius << " C = " << fahrenheit << " F\n";
    cout << "Percent of boiling: " << percentOfBoiling << "%\n";
    cout << "High temperature: " << isHighTemp << "\n";

    return 0;
}

Аналіз ключових рядків:

• Рядок 13: Формула * 9.0 / 5.0 використовує дійсні літерали (9.0, 5.0), щоб ділення не було цілочисельним. Якщо написати * 9 / 5, при celsius = 37 отримуємо 37 * 9 / 5 = 333 / 5 = 66 (ціле ділення!), а не правильне 66.6.
• Рядок 16: Тут теж поділ на 100.0 (дійсне), а не 100.
• Рядок 19: Результат порівняння зберігається у bool isHighTemp і виводиться як 0 або 1.

Приклад роботи:

Enter temperature in Celsius: 37
37 C = 98.6 F
Percent of boiling: 37%
High temperature: 1

Практичні завдання

Рівень 1 — Базовий

int a = 10, b = 3;

cout << a / b       << "\n";  // ?
cout << a % b       << "\n";  // ?
cout << a / 3.0     << "\n";  // ?
cout << (a > b)     << "\n";  // ?
cout << (a == 10)   << "\n";  // ?
cout << (a != b)    << "\n";  // ?
cout << !true       << "\n";  // ?
cout << (a > 5 && b < 5) << "\n"; // ?

int x = 7, y = 2;
double result = x / y;        // Має бути 3.5
bool isEqual = (x = y);       // Має перевіряти рівність
bool isPositive = x > 0 && < 100;  // Синтаксична помилка

Рівень 2 — Логічний

Рівень 3 — Творчий

Enter weight (kg): 75
Enter height (m): 1.75
BMI: 24.49
Normal weight: 1
Overweight: 0

Enter digit: 7
Digit value: 7
Square: 49

Підсумок