1. Переменные int: зачем нужны и как с ними работать
На старте кажется, что числа в программе можно использовать «как в тетрадке»: написал 2 + 2 — и прекрасно. Но реальная программа обычно не живёт одной строкой: она хранит данные, меняет их, использует результат вычислений несколько раз и печатает разные куски в разном месте. Поэтому нам нужен способ сказать: «Вот это число — важное, давай дадим ему имя и будем к нему обращаться».
Тип int — самый базовый инструмент для этого. Он хранит целые числа: 0, 7, -12, 42. Без дробной части. Можно думать о нём как о «коробке для целого числа», на которой мы пишем ярлык (имя переменной), чтобы не путаться.
Объявление, начальное значение и присваивание
Когда вы создаёте переменную, вы делаете две вещи: придумываете ей имя и выбираете тип, то есть «что именно» там будет храниться. А потом обычно сразу даёте начальное значение, чтобы переменная не была «пустой» (в C++ это особенно важно).
Посмотрим на минимальный пример. Здесь мы не делаем ничего умного — просто храним возраст и печатаем его. Но именно так начинается почти любая программа: с данных.
#include <iostream>
int main() {
int age = 18;
std::cout << "Age = " << age << '\n'; // Age = 18
}
Обратите внимание на три момента. Во‑первых, int age = 18; читается как «создай переменную age типа int и положи туда 18». Во‑вторых, в std::cout можно печатать и текст, и числа, просто «склеивая» их оператором <<. В‑третьих, перевод строки '\n' помогает сделать вывод аккуратным.
Теперь самое важное: переменная — это не константа. Её значение можно менять с помощью присваивания.
#include <iostream>
int main() {
int score = 0;
std::cout << score << '\n'; // 0
score = 10;
std::cout << score << '\n'; // 10
}
Здесь строка score = 10; означает «замени старое значение на новое». И да: знак = в программировании обычно означает не «равно», а «положи/запиши».
2. Арифметика int и скобки в выражениях
Операции +, -, * для целых чисел
С арифметикой в int всё выглядит очень знакомо, и это приятно: сложение, вычитание и умножение работают «как вы ожидаете». Правда, есть важный нюанс: результат тоже будет целым числом, потому что мы работаем в мире int. Пока что это звучит очевидно, но на делении это выстрелит особенно громко — и мы до этого дойдём.
Начнём с простого: посчитаем сумму, разность и произведение.
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a + b) << '\n'; // 9
std::cout << (a - b) << '\n'; // 5
std::cout << (a * b) << '\n'; // 14
}
Скобки тут не обязательны, но новичка они часто спасают: вы явно показываете, что именно хотите посчитать, и меньше шансов превратить выражение в ребус.
Ещё один полезный приём — сохранять результат вычисления в переменную. Это делает код читаемым: сначала вычислили, потом использовали.
#include <iostream>
int main() {
int apples = 3;
int pears = 4;
int total = apples + pears;
std::cout << total << '\n'; // 7
}
Скобки: для смысла и читаемости
Когда выражения становятся чуть длиннее, мозг начинает делать то же, что и компилятор: пытаться понять порядок вычислений. Проблема в том, что мозг устаёт, а компилятор — нет. Поэтому хороший стиль в программировании часто выглядит как «ставим скобки там, где человеку может быть неочевидно». Это не слабость, это забота о будущем себе (и о менторе, который будет проверять ваш код).
Сравните два варианта: формально они могут быть эквивалентны, но читаются по‑разному.
#include <iostream>
int main() {
int x = 10;
int y = 3;
int r1 = x + y * 2;
int r2 = (x + y) * 2;
std::cout << r1 << '\n'; // 16
std::cout << r2 << '\n'; // 26
}
Скобки меняют смысл. И это отличный повод держать в голове правило: если формула важна, лучше сделать её очевидной глазами, а не надеяться на память о приоритетах операторов.
3. Деление / и остаток % для int
Деление /: результат всегда целый
Оператор / для int делает целочисленное деление. Это значит: результат тоже int, и дробная часть не округляется «по правилам математики», а просто отбрасывается.
Проверим на классическом примере:
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a / b) << '\n'; // 3
}
Почему 3, а не 3.5? Потому что int не умеет хранить .5. Он хранит только целые значения. Поэтому программа берёт целую часть и выкидывает остальное.
Это поведение удобно, когда вы считаете «сколько целых предметов помещается». Например, сколько пачек печенья по 6 штук можно собрать из 25 печенек. Но это же поведение опасно, если вы ожидали «настоящее» деление. Пока мы работаем только с int, просто зафиксируйте правило: int / int даёт int.
Отдельно отмечу, что с отрицательными числами результат тоже будет целым. В современном C++ отбрасывание дробной части идёт в сторону нуля, то есть -7 / 2 будет -3.
#include <iostream>
int main() {
int a = -7;
int b = 2;
std::cout << (a / b) << '\n'; // -3
}
Если вы сейчас подумали «ммм, а остаток тогда какой?» — вы мыслите как программист. Переходим к %.
Остаток %: что осталось после деления
Оператор % читается как «остаток от деления». Он работает только для целых чисел (в нашем случае — для int). И обычно используется в задачах вида «разложить по коробкам» или «разменять сумму» или «понять, делится ли число нацело».
Самый базовый пример:
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a % b) << '\n'; // 1
}
То есть 7 апельсин поделить на 2 человек будет 3 апельсина каждому и 1 в остатке.
Полезно помнить связку деления и остатка в виде формулы: a = (a / b) * b + (a % b)
Это не магия и не заклинание, а просто аккуратный способ сказать: «число a состоит из целого количества групп по b плюс остаток».
Давайте это прям проверим кодом:
#include <iostream>
int main() {
int a = 25;
int b = 6;
int q = a / b; // сколько полных групп
int r = a % b; // сколько осталось
std::cout << q << '\n'; // 4
std::cout << r << '\n'; // 1
}
Пока что это выглядит как «игрушка», но через пару задач вы начнёте видеть % везде: время на часах, чётность/нечётность, разбиение на страницы, перевод секунд в минуты, и так далее.
4. Деление на ноль недопустимо
В математике деление на ноль — не определено. В программировании это превращается в практическую проблему: выражения a / 0 и a % 0 недопустимы. Программа либо аварийно завершится, либо попадёт в совсем непредсказуемое поведение (что ещё хуже, потому что ошибки могут проявиться «где-то потом»).
Здесь важен не страх, а привычка: если у вас есть делитель, который теоретически может стать нулём, вы должны это контролировать. Пока мы ещё не проходили if, поэтому сегодня правило простое: в примерах и первых задачах не делим на ноль и держим в голове, что делитель должен быть ненулевым.
5. Мини‑приложение: «Автомат с монетами»
Сейчас мы напишем маленькую программу, которая выглядит как «часть реального мира»: у нас есть сумма денег и цена товара, и мы хотим узнать две вещи. Во‑первых, сколько товаров можно купить. Во‑вторых, сколько денег останется. Это идеальная задача для пары / и %.
Важно: пока мы не умеем вводить данные, поэтому числа будут «захардкожены» в коде. Это нормально: сегодня наша цель — не ввод, а арифметика.
Версия 1: считаем количество и сдачу
Представим, что у нас 275 центов (то есть $2.75), а печенье стоит 60 центов. Считаем.
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int cookies = moneyCents / cookiePrice;
int change = moneyCents % cookiePrice;
std::cout << cookies << '\n'; // 4
std::cout << change << '\n'; // 35
}
Тут прекрасно видно, зачем нам переменные: один раз задали цену и сумму, а дальше используем их в вычислениях и можем легко поменять сценарий, не переписывая всю программу.
Версия 2: делаем вывод понятнее
Пока вывод у нас «компьютерный»: просто числа в столбик. Давайте добавим подписи, чтобы стало похоже на нормальную консольную программу. Мы не используем строки как тип (это будет следующая лекция), но печатать текст в кавычках мы уже умеем.
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int cookies = moneyCents / cookiePrice;
int change = moneyCents % cookiePrice;
std::cout << "Cookies: " << cookies << '\n'; // Cookies: 4
std::cout << "Change: " << change << " cents\n"; // Change: 35 cents
}
Да, это уже похоже на приложение, а не на контрольную по арифметике.
Версия 3: ещё одна покупка
Допустим, после покупки печенек вы ещё хотите купить жвачку за 35 центов. У нас как раз есть сдача. Посчитаем, сколько жвачек можно купить на сдачу (это, кстати, тоже / и %, только с другими числами).
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int gumPrice = 35;
int cookies = moneyCents / cookiePrice;
int changeAfterCookies = moneyCents % cookiePrice;
int gums = changeAfterCookies / gumPrice;
std::cout << "Cookies: " << cookies << '\n'; // Cookies: 4
std::cout << "Gums: " << gums << '\n'; // Gums: 1
}
Здесь особенно видно, что переменные помогают держать «сюжет» программы. Мы не просто считаем числа, мы описываем процесс.
6. Типичные ошибки при работе с int, / и %
Ошибка №1: ожидать, что 7 / 2 даст 3.5.
Это одна из самых частых ловушек у новичков: мозг помнит школьную математику, а программа работает в мире int. В целочисленном делении дробная часть отбрасывается, потому что int не умеет хранить половинки. Если вам нужна дробь — это отдельная тема, но сегодня мы честно живём в мире целых чисел и принимаем его правила.
Ошибка №2: использовать % «для всего подряд».
Остаток — это не «крутая кнопка», а конкретная операция со смыслом «что осталось после деления на равные группы». Если вы не можете объяснить словами, что именно остаётся, скорее всего, % вы применяете наугад. А угадывание в программировании работает примерно так же, как «угадывание пароля»: иногда получается, но лучше не надо.
Ошибка №3: забыть, что a % 0 и a / 0 недопустимы.
Деление на ноль не просто «даёт ошибку». Оно ломает саму логику вычисления. Поэтому правило простое: делитель (то, на что делим) должен быть ненулевым. Позже, когда появятся условия (if), вы научитесь защищать программу от такого ввода. Сейчас же — просто не пишите такого кода и не подставляйте 0 в делитель.
Ошибка №4: писать длинные выражения без скобок и потом не понимать результат.
Формально компилятор разберётся, но человек — не всегда. В итоге вы получаете ситуацию «вроде всё правильно, но почему ответ не тот». Скобки — дешёвый способ сделать смысл выражения очевидным и для вас, и для того, кто будет читать код. В программировании это называется не занудством, а профилактикой багов.
Ошибка №5: путать “создать переменную” и “изменить переменную”.
int x = 10; — это создание переменной с начальным значением. x = 10; — это присваивание уже существующей переменной. Если попытаться «создать» переменную второй раз с тем же именем в том же месте, компилятор справедливо возмутится: «так, минутку, у нас тут уже есть x».
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ