Текст выступления:

Операции с целыми числами
1. Операции с целыми числами в информатике: от арифметики к программам

Целые числа — основа вычислений в памяти компьютера и «строительный материал» программ.

2. Почему целые числа важны в информатике

Начать разговор о программах удобнее всего с того, что лежит в их «скелете». В отличие от школьной арифметики, компьютер хранит целые числа в ограниченной по размеру памяти и опирается на строгую разрядность: сколько бит выделено, такой и «коридор» допустимых значений. Ошибка понимания этого коридора способна привести к переполнению, неверным итогам или даже сбою логики.

Именно поэтому целые числа особенно часто встречаются там, где нужны точные, дискретные решения: при счёте, сравнении величин, поиске максимумов и минимумов, а также при организации циклов. Когда вычисление должно работать без «погрешности на дроби», выбирают именно целочисленную арифметику — фундамент для индексирования, условий и перебора.

3. Понятие целого числа и его место среди типов данных

Целое число — это значение без дробной части: отрицательное, ноль или положительное. Такая характеристика на уровне идеи кажется простой, но в программировании она превращается в важный вопрос: какие именно значения и представления допускает конкретный тип данных.

В языках программирования типы данных различают по тому, что они «разрешают» программе. Есть вещественные числа, есть символьные и логические, есть строковые типы. Целые занимают среди них особое место: они задают дискретный шаг между соседними значениями — без «промежутков», которые возникают у дробных величин.

При этом различают целые типы по размеру и диапазону: привычные примеры вроде byte, short, int, long (названия зависят от языка) отличаются количеством бит. Это влияет сразу на два практических аспекта: сколько памяти займёт переменная и какие значения будут корректными. Слишком узкий тип — и значение может выйти за границы допустимого диапазона, а слишком широкий — и вы тратите ресурсы без необходимости.

4. Двоичное представление целых чисел

Чтобы понять, почему диапазоны так критичны, нужно заглянуть внутрь представления. В информатике любой «готовый» ответ программы в конечном счёте упакован в двоичный вид: последовательность бит, где каждый бит — либо 0, либо 1.

Когда говорят «двоичное представление целых чисел», обычно имеют в виду два слоя. Первый — это то, как число раскладывается на биты: как из набора нулей и единиц получается величина. Второй — это соглашение о знаке и интерпретации: одно и то же двоичное слово может означать разные числа в зависимости от того, рассматривается ли оно как знаковое или беззнаковое.

Технические иллюстрации на таких слайдах помогают увидеть простую мысль: компьютер не «думает» категориями наших десятичных записей. Он оперирует фиксированной шириной двоичного кода, а значит, число всегда ограничено размером своей двоичной «упаковки».

5. Диапазон целых чисел при разной разрядности

Диапазон целых чисел — одна из тех тем, где график обычно говорит сильнее любых рассуждений. Основная идея такая: увеличение разрядности расширяет доступный коридор значений примерно в два раза, потому что число возможных комбинаций бит растёт экспоненциально.

Если мысленно перейти от меньшего типа к большему — например, от 8 бит к 16 — доступных битовых комбинаций становится больше в разы. Для пользователя это означает меньше неожиданных выходов за границы: риск переполнения снижается, а программа чаще ведёт себя так, как задумано.

Но важнее не «статистика», а вывод для мышления программиста: выбирая тип данных, нельзя опираться лишь на удобство. Нужно учитывать размер диапазона и то, какие значения реально будут встречаться в данных. Даже самая стройная формула может дать неверный результат, если её вычисление «вылезло» за рамки представления.

6. Сложение целых чисел: правило и примеры

Сложение — операция, с которой проще всего связать интуицию: в математике оно подчиняется знакомым законам, а в компьютере реализуется через работу с битами. Главное отличие заключается в том, что компьютер учитывает фиксированный диапазон значений типа данных.

Если сумма по смыслу помещается в допустимые границы, вычисление оказывается предсказуемым. Но как только результат выходит за пределы диапазона, включается механизм переполнения, и поведение может стать неожиданным.

Отдельная тонкость проявляется в случае разных знаков слагаемых. Когда знаки различаются, логика сложения сводится к сравнению модулей: компьютер по сути определяет, какое из чисел «перевешивает» по величине, и затем формирует знак результата по большей по модулю величине. Поэтому даже при кажущейся простоте «+» на практике оно тесно связано с тем, как представляются отрицательные числа.

Примеры наглядно закрепляют это: 7 + 5 = 12, −4 + 9 = 5, −6 + (−3) = −9. В программах сложение применяют в накопительных алгоритмах: суммирование элементов, подсчёт количества значений, обновление счётчиков в циклах — то есть там, где важна точность без лишней «плавающей» неопределённости.

7. Вычитание и связь с отрицательными числами

Вычитание часто воспринимается как самостоятельная операция, но для понимания удобно перевести её в язык сложения. Вычитание можно рассматривать через прибавление противоположного числа: a − b = a + (−b). Это не просто формула для доски — такой взгляд помогает разбирать алгоритмы и объяснять, почему отрицательные значения становятся ключевыми.

В примерах это видно напрямую: 10 − 3 = 7, 5 − 8 = −3, −2 − 6 = −8. А на вычислительном уровне вычитание опирается на то, как система интерпретирует отрицательные числа и как она работает с их двоичными кодами.

Здесь появляется причина многих программных ошибок: они чаще возникают не из-за «математики» как таковой, а из-за знака результата и из-за порядка действий в выражениях. В программировании приоритеты операций и правила вычисления выражений могут заставить формулу работать иначе, чем ожидается на интуитивном уровне, а неверное чтение знаков и скобок способно изменить ответ или «сломать» условие.

Именно поэтому при работе с целыми важно не только знать правила алгебры, но и понимать, как эти правила переводятся в вычислительную модель.

8. Примеры вычислений с целыми числами

После разговоров о правилах полезно зафиксировать их на конкретных выражениях. На таких слайдах обычно показывают, как применяются арифметические правила и какой «смысл результата» закрепляется в программе.

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

Отдельно подчёркивается различие между видами деления. В программировании нужно особенно внимательно отличать целочисленное деление, деление с остатком и вещественное деление. Одно и то же выражение на «бумаге» может дать разный результат в зависимости от того, какой оператор выбран и какой тип данных используется. Поэтому даже простая арифметика в коде — это в первую очередь вопрос корректного выбора операции.

9. Умножение целых чисел и правило знаков

Умножение у целых чисел кажется «самой спокойной» операцией, но и оно подчиняется строгой логике знаков. Для целых чисел знак результата определяется правилами: произведение двух чисел одного знака даёт положительное, а произведение чисел разных знаков — отрицательное.

Когда это правило корректно учитывается, проще предсказывать поведение программы: результат умножения управляет условиями, границами циклов, вычислением масштабов и преобразований.

Кроме того, умножение быстро «разгоняет» величины. Там, где сумма могла бы ещё поместиться в диапазон, произведение часто приводит к росту по модулю и повышает риск выхода за допустимые пределы типа данных. Поэтому умножение обычно требует аккуратного контроля переполнения, особенно когда входные значения могут быть большими или поступают из внешних источников.

10. Деление целых чисел и остаток от деления

Деление целых чисел — операция, где особенно хорошо видно отличие целочисленной арифметики от школьного представления о дробях. При целочисленном делении результат возвращается без дробной части: «сколько полных групп помещается». Остаток при этом показывается отдельно и демонстрирует то, что не вошло в эти полные группы.

Пример: 17 ÷ 5 = 3, остаток 2. Смысл такой: после разбиения остаётся 2 единицы, которые не образуют полного делимого блока. Этот остаток — не «ошибка», а полезная информация.

В программировании операция остатка работает как инструмент разбиения данных и как основа для индексирования. Например, она помогает вычислять положение элемента в циклических структурах, определять периодичность и строить схемы перебора по модулю. Поэтому остаток — это маленькая математическая деталь, которая в коде превращается в мощный механизм.

11. Порядок вычислений: от скобок к результату

Чтобы арифметика в выражениях не превращалась в ловушку, нужен порядок вычислений. Этот порядок задаётся приоритетами операций и тем, как система трактует одинаковый приоритет — обычно слева направо.

В реальном коде выражения почти никогда не бывают «простыми в одну строку». Скобки подсказывают, что вычислять первым, а затем операторные приоритеты определяют последовательность остальных шагов. Например, умножение и деление обычно выполняются раньше сложения и вычитания, а скобки способны переставить привычную очередность.

Такой flowchart-слайд обычно подводит к практической привычке: прежде чем доверять результату, стоит мысленно пройти маршрут — от скобок к итоговому значению. Это экономит время при отладке и помогает увидеть, где именно выражение начинает вести себя не так, как ожидается.

12. Переполнение разрядной сетки

Тема переполнения — один из самых важных поводов относиться к целым числам с уважением. Переполнение возникает, когда результат вычисления выходит за границы диапазона типа данных.

Например, для 8-битного знакового числа 127 + 1 не помещается и может «перевернуться» к −128. Для человека это звучит как парадокс, но для компьютера всё логично: он не может хранить число вне выделенного количества бит и вынужден интерпретировать битовый результат по правилам текущей модели представления.

В больших программах переполнение встречается часто: при суммировании, подсчёте элементов, вычислении длин массивов и обработке больших объёмов данных. Там сумма может стать больше максимально допустимой, даже если отдельные шаги выглядят безобидно.

Последствия зависят от того, как используется переполненный итог. Возможны неверные значения, сбои в вычислительной логике, и иногда — что особенно серьёзно — уязвимости безопасности, если число дальше используется для выделения памяти, обращения к массивам или построения условий проверки.

Выход всегда один: надёжное программирование требует контроля диапазона — проверять границы перед операциями, использовать более широкий тип там, где это оправдано, и обязательно предусматривать обработку граничных случаев.

13. Как компьютер «подружился» с отрицательными числами: дополнительный код

Чтобы компьютер мог эффективно работать с отрицательными числами, понадобился общий и удобный способ их кодирования. Исторически задача была непростой: ранние механические и релейные устройства сталкивались с тем, что хранение знака и величины по отдельности усложняет вычисления.

Решение, которое сегодня считается стандартом во многих вычислительных архитектурах, — дополнительный код. Его идея позволяет выполнять операции сложения и вычитания практически единообразно, когда знаковые числа обрабатываются тем же «двигателем» на уровне двоичных схем.

Смысл дополнительного кода можно представить образно: отрицательное число кодируется так, чтобы в сумме с ним получался ноль в рамках фиксированной разрядности. Тогда вычитание сводится к прибавлению, а логика схем становится проще и надёжнее.

На уровне культуры вычислений это одна из тех технологий, которая стала настолько «незаметной», что большинство пользователей о ней не думает — пока не столкнётся с переполнением или неожиданным поведением при выходе за диапазон. Слайд с короткими «историями» обычно помогает закрепить образ: отрицательные числа перестают быть исключением и становятся частью общей машины арифметики.

14. Целые числа в алгоритмах и циклах

После того как понятно, как целые числа представлены и как выполняются операции, естественный следующий шаг — увидеть их роль в алгоритмах. Целые числа почти всегда являются основой для счётчиков: в цикле for переменная последовательно принимает значения 0, 1, 2, 3 и далее, двигаясь на фиксированный шаг.

В задачах поиска минимума и максимума, а также при подсчёте элементов промежуточные результаты тоже удобно хранить в целых переменных. Причина практическая: сравнение и обновление значений не требуют дробной части — дробность здесь не даёт смысла, но увеличивает вероятность ошибок при сравнении и преобразованиях.

Отдельный пример — массивы и индексы. Индексы почти всегда целые, потому что они обозначают конкретные позиции элементов. Ошибка в вычислении индекса — даже на один — способна привести к выходу за границы массива и нарушить логику программы. Иногда это выглядит как «случайный баг», но за этим почти всегда стоит неправильная арифметика или неверное понимание деления и остатка.

Наконец, нарушение целочисленности или неверный порядок вычислений способен сломать цикл: он может завершиться слишком рано, уйти в бесконечные повторения или посчитать не те элементы. Поэтому целые числа — это не просто тип данных, а инструмент, который управляет временем выполнения и корректностью алгоритма.

15. Где встречаются операции с целыми числами в повседневных программах

Иногда кажется, что целые числа — тема учебников, а в реальности работают «картинки» и интерфейсы. Однако внутри обычного приложения почти всегда идут вычисления, где используются индексы, суммы, длительности и коды состояний — то есть целые числа.

Например, счётчик сообщений, номер текущего экрана, обработка очередей, управление прогрессом, вычисление страниц пагинации и даже статусы в логике приложения — всё это опирается на дискретные значения. Когда пользователь нажимает «следующее», программа фактически выполняет операции над целыми индексами и сравнивает их с границами.

Анализ типичных задач показывает, что основной объём таких вычислений приходится именно на счётчики и индексы: они обслуживают почти все алгоритмы, потому что требуют точных дискретных значений. И поэтому понимание целочисленной арифметики — это прямой путь к более надёжным программам, меньше «необъяснимых» ошибок и более осмысленной проверке граничных случаев.

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

16. Типичные ошибки при работе с целыми числами

Переходя от теории к практике, полезно остановиться на самых частых «сбоях мышления» при работе с целыми числами. Они происходят не потому, что числа сложны, а потому, что программисты, математики и даже инженеры по привычке предполагают то, чего язык и архитектура не гарантируют.

Первая ошибка — неверное ожидание диапазона. Многие считают, что «int всегда достаточно», хотя реальная разрядность зависит от языка, компилятора и платформы. В результате операции над значениями, которые формально «выглядят небольшими», внезапно упираются в границы типа. Такие переполнения — классическая причина «невозможных» отрицательных результатов там, где ожидается положительный счёт.

Вторая ошибка — путаница знаковых и беззнаковых представлений. Для человечного понимания минус означает отрицательное число, но в двоичном виде знаковая величина и беззнаковая трактуются по-разному. Отсюда возникают ошибки сравнения и сдвигов: условие может работать «на глаз неправильно», потому что компилятор интерпретирует битовую маску не так, как ожидалось.

Третья ошибка — ожидание арифметики «как в тетради». В реальном программировании важно помнить о порядке вычислений, типах промежуточных результатов и правилах приведения типов. Например, выражение может сначала быть вычислено в узком типе, а уже затем расширено. Это похоже на попытку измерить расстояние линейкой, а затем объявить: «потом пересчитаем в метры» — но ошибка уже встроена в первые миллиметры.

Четвёртая ошибка — игнорирование сдвигов и деления. Сдвиги обычно трактуются как операции над битами, но знаковые типы добавляют нюансы: результат зависит от того, выполняется ли арифметический сдвиг или логический. Деление целых — отдельная ловушка: оно не даёт дробную часть, а означает усечение. Там, где требуется среднее, доля или процент, «целочисленность» превращает аккуратную формулу в систематическую погрешность.

Пятая ошибка — отсутствие валидации входных данных и границ. Самый практичный подход — воспринимать целые числа как потенциально опасные: пользователь может ввести значение больше диапазона, получить отрицательное там, где ожидается индекс, или подать неожиданный формат. В информатике это принцип «защищённого программирования»: прежде чем выполнять вычисления, проверяют тип, диапазон и инварианты.

Эти ошибки можно свести к простой мысли: целые числа ведут себя предсказуемо, но предсказуемость не равна «всегда правильно». Следующий слайд помогает понять, почему выбор типа так влияет на результат и память.

17. Сравнение целых типов данных в языках программирования

Чтобы легче не попадать в перечисленные ловушки, нужно понимать, как устроен компромисс между диапазоном и памятью. Даже если два типа называются одинаково — например, «целое» или «int», — их реальные пределы зависят от языка, модели данных и платформы.

Общий принцип один: чем шире тип, тем больше допустимые значения и тем больше памяти он занимает. Это не просто техническая деталь. Когда тип узкий, число быстрее достигает верхней границы и начинает «переворачиваться» по модулю или выдавать некорректные результаты в зависимости от правил языка. Когда тип широкий, таких проблем меньше, зато растёт потребление памяти — особенно заметно это на длинных массивах, больших базах данных и вычислениях в циклах.

Сравнение разных целых типов в учебных материалах почти всегда подчёркивает одно и то же: выбор — это баланс. Например, для счётчиков, которые не могут превышать определённого лимита, достаточно узкого типа. Но для сумм на больших массивах или для работы с данными, чья величина заранее неизвестна, узкий тип может оказаться слишком оптимистичным.

Здесь полезна небольшая историческая ремарка. В ранних вычислительных системах разрядность была фиксированной: программы буквально «подстраивались» под железо. Затем появились стандарты и типы с более понятными правилами, но зависимость от архитектуры никуда не исчезла. Современные вычисления часто идут на 32- или 64-битных платформах, и ошибка в выборе ширины типа до сих пор способна привести к уязвимостям и редким, трудно воспроизводимым багам.

Ключевой вывод для практики следующий: тип выбирают не «потому что так привычнее», а по смыслу данных. Если есть вероятность работы с большими значениями — расширяют разрядность. Если данные ограничены — экономят память. В противном случае растёт риск переполнения, а вместе с ним и вероятность логических ошибок в условиях, циклах и вычислениях.

Этот вывод напрямую подводит к следующему шагу: как целые числа выглядят в задачах, которые кажутся повседневными, но требуют дисциплины вычислений.

18. Практические примеры из информатики и реальной жизни

Теперь посмотрим, как целые числа проявляются в задачах, которые встречаются почти ежедневно. Важно, что они дискретны: значит, логика работы с ними подчиняется целочисленным правилам, а не «математическим мечтам» о дробях.

Во‑первых, целые числа используются там, где мы считаем количество или фиксируем идентификаторы: число файлов, номер страницы, возраст в полных годах. Такой выбор не случайность. Эти величины дискретны и не требуют дробных значений — а попытка заменить их дробями часто добавляет лишние преобразования и усложняет инварианты.

Во‑вторых, в играх и на интерактивных полях целые числа становятся координатами объектов, параметрами скорости в пошаговых режимах и баллами. На «клеточном» поле координаты обязаны быть целыми, иначе теряются правила размещения. В электронных таблицах и приложениях для оценок целочисленные суммы и промежуточные результаты удобны: они быстрее вычисляются, а отображение оценок интуитивнее для человека.

В‑третьих, системы посещений, лайков, шагов и сообщений обычно опираются на целые счётчики. Это обеспечивает точные обновления и понятную логику условий: например, «когда число достигло порога, включаем бонус». Здесь дробность не имеет смысла, потому что «0,7 лайка» или «2,3 сообщения» не соответствует реальному процессу.

Эти примеры полезны тем, что показывают: целые числа — не абстракция. Но именно из-за своей повседневности они иногда неправильно «подменяются» случайными формулами, которые забывают о диапазоне и валидации.

Следующий слайд формализует правильный порядок действий перед вычислениями — в виде алгоритма проверки целого числа.

19. Алгоритм проверки целого числа перед вычислениями

Чтобы вычисления были надёжными, полезно мыслить процессом: сначала контролируем входные данные, затем выполняем операцию. Такая последовательность особенно важна, когда целое число приходит извне — из ввода пользователя, из файла, из сети или из датчика.

Алгоритм проверки можно представить как цепочку шагов. Сначала оценивается сам факт корректности: число должно быть распознано как целое, без неожиданных символов и без ошибок разбора формата. Затем проверяются границы: значение не должно выходить за допустимый диапазон выбранного типа.

После этого проверяют инварианты задачи: например, если число используется как индекс массива, оно должно быть неотрицательным и не превышать максимальный допустимый индекс. Если число применяют как параметр для вычисления, необходимо убедиться, что оно удовлетворяет ограничениям модели — скажем, «период не равен нулю», «объект существует», «знаковость соответствует ожиданию».

Только когда валидация выполнена, выполняется основная операция. Это практическое правило защищённого программирования: отделять проверку от вычисления, чтобы ошибка входных данных не превращалась в переполнение, некорректное сравнение или падение программы.

Такой подход снижает количество «скрытых» дефектов. Он также облегчает отладку: вместо загадочного результата после вычисления появляется понятная причина — именно на этапе проверки стало ясно, что вход не подходит.

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

20. Итоги: что важно знать об операциях с целыми числами

Целые числа — фундаментальный тип данных: их двоичное представление, ограниченный диапазон и правила для знаковых операций влияют на результат почти всех вычислений. Важны разрядность, дополнительный код, порядок операций и переполнение.

Эта «пятёрка» работает как чек‑лист на практике. Разрядность отвечает за то, в каких пределах вообще возможно корректное значение. Представление со знаковыми числами — в частности, дополнительный код — определяет поведение отрицательных величин в сложении, вычитании и сдвигах. Порядок операций и приведения типов влияет на то, где именно возникает ошибка округления или переполнения. А переполнение — ключевой риск: оно может не проявиться явно, но разрушить логику условий и сделать поведение программы нестабильным.

Самое ценное в этих выводах — привычка думать о данных как о дискретных и ограниченных сущностях. Тогда выбор типа становится инженерным решением, алгоритм валидации — стандартной процедурой, а итоговые вычисления — предсказуемыми.

Источники

Ахо А. В., Хопкрофт Дж. Е., Ульман Дж. Д. Структуры данных и алгоритмы. М.: Вильямс, 2020.

Кнут Д. Искусство программирования, том 1. Основные алгоритмы. М.: Вильямс, 2017.

Таненбаум Э. Архитектура компьютера. М.: Питер, 2018.

Седжвик Р. Алгоритмы на C++ / Фундаментальные алгоритмы. М.: Лаборатория знаний, 2019.

Ахо А. В., Хопкрофт Дж. Э., Ульман Дж. Д. Структуры данных и алгоритмы. — М.: Издательский дом «Вильямс», 2017.

Кормен Т. Х., Лейзерсон Ч. Э., Ривест Р. Л., Штайн К. Алгоритмы: построение и анализ. — М.: Вильямс, 2016.

Седжвик Р. Фундаментальные алгоритмы на C++ / The C++ Programming Language: практики работы с типами и арифметикой. — М.: Бином, 2015.

Учебные материалы по базовым целочисленным типам в языках программирования: разрядность, знаковость, правила приведения типов. — Электронный учебный курс (локальная методическая разработка).