Что такое integer

Тип данных Integer.

Тип INTEGER (целый). Этот тип представляет множество целых чисел диапазона от -32768 до 32767. В памяти ЭВМ под целое число отводится два байта (16 бит).

Наибольшему значению целого числа 32767 соответствует стандартный идентификатор MAXINT, а наименьшему – выpaжeниe NOT(MAXINT)=-(MAXINT+1), или число -32768. Операции, проводимые над целыми числами: «+» сложение, «-» вычитание, «*» умножение, DIV — целочисленное деление, MOD — остаток от целочисленного деления, AND — арифметическое ‘И’, OR — арифметическое ‘ИЛИ’, NOT – арифметическое отрицание, XOR — исключающая дизъюнкция. Примеры использования этих операций приведены в таблице1.

Любая из этих операций выполнима над двумя целыми числами, если абсолютная величина результата не превышает MAXINT (для умножения). В противном случае возникает прерывание программы, связанное с переполнением.
Например: требуется вычислить выражение 1000 * 4000 div 2000. Поскольку операции умножения и деления имеют один приоритет и выполняются слева направо в порядке записи арифметического выражения, то при умножении произойдет прерывание, связанное с переполнением. Выход из этой ситуации возможен при изменении порядка выполнения операций умножения и деления, для чего используются круглые скобки ==> 1000 * (4000 div 2000).
Предусмотрено представление целых чисел в шестнадцатеричной системе счисления. Форма записи таких чисел $Х, где X — целая константа, а символ $ — признак. Примеры: $57, $1FF. Напомним, что в шестнадцатеричной системе счисления цифры 10, 11, 12, 13, 14 и 15 заменяются латинскими буквами А, В, С, D, Е и F соответственно.
Кроме типа INTEGER в языке Pascal предусмотрены и другие целые типы данных BYTE, SHORTINT, WORD и LONGINT (таблица 2). Все эти типы определены на множестве целых чисел, характеризуются одним набором арифметических операций и отличаются диапазоном значений и объемом занимаемой памяти.

Типы данных и int в программировании

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

Далее предстоит изучить типы данных в C++, C и Java. Особое внимание будет уделено целочисленному виду. Необходимо выяснять не только то, что обозначает соответствующий тип, но и его ограничения, обозначения и возможные свойства.

Тип данных – это…

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

Типы отвечают за определение двух вещей:

1. Диапазон (границы) допустимых значений. Пример – в Java поддерживаются две группы типов: целый и рациональный. Это связано с техническими особенностями работы устройств. В C++ их намного больше: дроби, символы, пустой тип, строки, целое число, числа с плавающей запятой двойной точностью.
2. Набор операций, которые можно выполнять. Пример – умножение применяется для вида «целое число». Аналогичную операцию с текстом производить не имеет никакого смысла. Умножать «родитель» на «машина» – это бессмыслица.

Языки программирования умеют распознавать различные виды информации. Это значит, что Java и другие ЯП не позволяют умножать строчку на строчку. А вот целое число на другое целое или дробное – запросто.

Какими бывают виды информации: глобальная классификация

Любой код подразумевает оперирование электронной информацией. Она обладает собственной природой и может быть по-разному организована. Этот момент напрямую влияет на удобство работы с ней.

Глобально поделить все типы информации в Java и других языках разработки можно на:

• примитивные – те, что предопределены в языке;
• ссылочные – они могут быть созданы разработчиком самостоятельно.

Целые числа относятся к примитивным data types. Далее они будут рассмотрены более подробно.

Разновидности целых видов данных

Основным видом информации является целочисленный. Он обозначается как int (integer). Разрядность у него равна разрядности машинного слова процессора, на котором запущено приложение. Иногда необходимо пользоваться более «крупными» и «мелкими» разрядностями. Из-за этого возникла классификация целых.

Она включает в себя:

• однобайтные целые – диапазон значений от -128 до +127 (8 бит);
• короткие целые – диапазон от -32 768 до +32 767 (16 бит);
• длинные целые – границы определяются в диапазоне от -2 147 483 648 до 2 147 483 647 (32 бита);
• двойные длинные – границы являются определенными в пределах -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 (64 бита).

Для экономии памяти значения переменной integer может быть беззнаковым. Оно помечается как unsigned. Такие переменные позволяют увеличить maximum значение еще на единицу. Некоторые разработчики рекомендуют не пользоваться беззнаковыми целочисленными из-за отсутствия реализации в процессоре компьютера. Некоторые языки разработки не поддерживают работу с беззнаковыми типами. К числу таких можно отнести Java.

В C++

Целое число является базовым типом. Он встречается почти в каждом приложении и обозначает целые, подобно математическим значениям. В C++ integers представлены:

1. Signed char – один символ. Занимает в памяти 1 байт. Максимальное значение составляет 127, минимальное – -127.
2. Unsigned char. Хранит значения в диапазоне от 0 до 255.
3. Char. Обозначает один символ в ASCII. Занимает 8 бит памяти и способно хранить значение в пределах от -127 до 127 или от 0 до 255.
4. Short. Это целое число, максимальное значение которого составляет 32 767, а минимальное – -32 768. Занимает 16 бит и может обозначаться как short int, signed short int или signed short.
5. Unsigned short – целочисленный тип со значениями от 0 до 65 535. Занимает 2 байта памяти.
6. Integer – тип данных, встречающийся чаще всего. Максимальное значение его составляет 2 147 483 647, а минимальное – -2 147 483 648 при 4 байтах. Если оно занимает 2 байта, то показатели варьируются от -32 768 до 32 767. Он всегда больше или равен типу short, а также меньше или равен типу long.
7. Unsigned int – положительное целое число. Может занимать 16 или 32 бита.
8. Long type. Тип, который занимает 4 или 8 байта. Диапазон варьируется от -2 147 483 648 до 2 147 483 647 или от -9 223 372 036 854 775 808 до 9 223 327 036 854 775 807.
9. Long long. Принимает значения от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. Отнимает 64 бита или 8 байт.
10. Unsigned long long.
11. Unsigned long – определяется в пределах от 0 до 4 294 967 295. В памяти занимает 32 бита.

Тип integer в любом языке разработки позволяет выполнять различные операции над данными. Они будут отличаться в зависимости от определенного вида информации.

Операции над int

Независимо от вида ints (будь то 2 31 или 1), значащих целочисленные данные, разработчик сможет выполнять с ними разные действия. К ним относят в первую очередь арифметические операции:

1. Сравнение. Здесь допускается применение соотношения «равно» (=, ==), «не равно» (!=, <>), «больше» (>), «меньше» (<), «меньше или равно» (<=), «больше или равное» (>=№.
2. Инкременты и декременты. Это арифметическое увеличение (++) или уменьшение (—) на единицу. Часто соответствующие операции выделены в отдельные манипуляции. Это связано с тем, что их используют счетчики.
3. Сложение и вычитание (+ и -).
4. Деление (/). Сюда же можно отнести получение остатка (%). Некоторые процессоры дают возможность проводить обе операции за одну инструкцию.
5. Инверсия знака и получение абсолютного значения.
6. Получение знака. Результатом часто выступает 1 для положительных значений числа, а также -1 для отрицательных. Нуль обозначается как 0.
7. Возведение в степень (^).

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

По битам

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

1. Битовый сдвиг вправо или влево.
2. Уточнение знака по старшему биту. Это относится только к целым числам со знаком.
3. Чтение и установку младшего бита. Используется для управления четностью.
4. Побитовое «и» и «или».

Базируются перечисленные операции на особенностях позиционного двоичного кодирования. Они обрабатываются быстрее, чем арифметические действия.

Здесь можно увидеть больше примеров переменных типа integer. Лучше изучить этот вопрос в любом языке разработки помогут дистанционные компьютерные курсы.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus !

Python для подготовки к олимпиадам, начальный уровень (7-9 классы) (СОШ г. Набережные Челны)

Теоретический материал по теме «Целочисленная арифметика»

Целочисленный тип (int) в Python

Д.П. Кириенко — Программирование на языке Python (школа 179 г. Москвы)

Для хранения целых чисел в Python используется тип int (от англ, integer — целое число). Этот тип позволяет хранить как положительные, так и отрицательные числа, при этом сколь угодно большие (в отличие от большинства языков программирования, где целочисленная переменная обычно занимает лишь несколько байт). Более точно, размер числа ограничен лишь имеющейся памятью.

Для преобразования к целому типу используется функция одноименная с именем типа — int:

s = int(input()) t = int(2.5) 

Для целых чисел определены арифметические операции:

* умножение (пропускать его в выражениях вида 2 * х нельзя);

\// целочисленное деление (дробная часть отбрасывается);

\% остаток от деления;

** возведение в степень.

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

(х — а) * 2 — (а — (1 — с))

Функция abs(x) возвращает модуль (абсолютное значение) числа х.

Присваивания вида х = х + а, х = х // а и т.п. можно писать сокращенно: х += а, х //= а.

Пример считывания одного числа

s = int(input ()) 

Пример считывания двух чисел, вводимых в разных строчках

s = int(input()) t = int(input ()) 

Пример считывания двух чисел, вводимых в одной строке через пробел

s, t = map(int, input().split()) # читаем строку, режем по пробелу # с помощью split, и к каждой части # применяем функцию int 

Подробней о real и integer

В одном из прошлых уроков, я уже рассказывал об особенностях числовых типов real и integer. В этом уроке рассмотрим всё более подробно, а также рассмотрим проблемные примеры из прошлых уроков.

Для полного понимания темы, необходимо знать двоичную систему счисления. На мой взгляд, будет сложно объяснить двоичную систему счисления новичку картоделу. Но скорее, не потому, что это какая-то сложная тема, а потому, что эти знания ему больше не пригодятся и лишь запутают его. Поэтому я не буду объяснять всё до мелочей, если сильно захотите, то сами найдете в интернете видео\статью о двоичной системе счисления и устройстве чисел с плавающей точкой.

Разница между числовыми типами

Вы уже знаете о некоторых различиях между real и integer, но я повторю их.
Integer – это любое целое число (-5, 0, 6).

Real – это число с плавающей точкой. Таким числом может быть как целое число, так и конечное дробное (-5, -2.554, 0, 1, 5.5).

Преобразование типов

Раньше я не акцентировал внимание на том, что значения типа real и значения типа integer это хоть и числа, но это разные типы данных. Компьютер хранит и вычисляет их по-разному, для него это вообще две разные вещи. А если они где-то используются вместе, например, в выражении, то в итоге все значения будут преобразованы к одному типу.

Посмотрите на такой код:
Скопировать в буфер

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = r local real b = i endfunction

Такой код не компилируется потому, что мы пытаемся присвоить значение типа real переменной «a» с типом integer. Надеюсь, вы помните, как преобразовывать в друг друга типы real и integer с помощью функций R2I и I2R. Исправим ситуацию, добавим преобразование типов:

Скопировать в буфер

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = R2I(r) local real b = i endfunction

Теперь код компилируется и работает, хоть он ничего полезного и не делает. Как вы заметили, я преобразовал только значение с типом real перед тем, как положить его в переменную «a» с типом integer, но ничего не сделал со значением типа integer перед тем, как положить его в переменную «b» с типом real. Это не значит, что там нет преобразования, просто преобразование integer в real происходит автоматически и использовать функцию I2R не всегда нужно.

Теперь посмотрим на то, что случается со значениями при преобразовании:
Скопировать в буфер

function Test takes nothing returns nothing local integer i = 2 local real r = 2.5 local integer a = R2I(r) local real b = i call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 2 b = 2.000

Если преобразовать integer в real, то значение не изменится. А если преобразовать real в integer, то мы видим, что дробная часть исчезла. Обратите внимание на то, что при преобразовании real в integer, дробная часть именно исчезает, а не округляется. Например, если преобразовать в integer значение 2.88888 то в результате всё равно будет 2.

При преобразовании integer в real значение гарантировано не изменится, поэтому компьютер может не беспокоиться о последствиях и преобразовать тип автоматически. В случае преобразования real в integer значение может измениться (потерять дробную часть) поэтому используя функцию R2I, вы как будто даёте своё согласие на «преобразование с потерями».

Также необходимо знать о том, что арифметические операции ведут себя немного по-разному в зависимости от типов значений, над которыми они проводятся. Если оба значения имеют тип integer, то в результате получится число с типом integer и оно потеряет дробную часть. А если хотя бы одно значение имеет тип real, то в результате получится число с типом real и если у него есть дробная часть, то она останется.

Возьмем пример из прошлого урока:
Скопировать в буфер

function Test takes nothing returns nothing local integer a = 2 * 2 / 3 local integer b = 2 / 3 * 2 call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + I2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 1 b = 0

С точки зрения математики, обе переменные должны быть равны 1.3333(3). Если учитывать то, что это целые числа, то обе переменные должны быть равны 1. Но в этом примере, значение переменной «b» по какой-то причине равно нулю. Давайте посчитаем всё вручную, чтобы понять, что тут происходит. Начнем с выражения «a = 2 * 2 / 3»:

2. 4/3 = 1.333(3) но это тип integer поэтому откинем дробную часть и у нас получится 1.
По итогу значение переменной «а» равно 1, всё сходится. Теперь посчитаем выражение «b = 2 / 3 * 2»:
1. 2/3 = 0.666(6) но это тип integer поэтому откинем дробную часть и у нас получится 0.

Всё сошлось, значение переменной «b» равно 0. Дело в том, что у литералов также есть тип, а все литералы в примере выше имеют тип integer. Если заменить тип переменных на real, то ничего не поменяется:

Скопировать в буфер

function Test takes nothing returns nothing local real a = 2 * 2 / 3 local real b = 2 / 3 * 2 call BJDebugMsg("a = " + R2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вывод на экран:
Скопировать в буфер

a = 1.000 b = 0.000

Чтобы числовой литерал имел тип real нужно, чтобы в числе была точка, например:
Скопировать в буфер

2.534 1.0 1. //писать ноль после точки необязательно, “1.” и “1.0” это одно и то же значение.

Сначала исправим пример с типом real, чтобы в результате обе переменные были примерно равны 1.333:
Скопировать в буфер

function Test takes nothing returns nothing local real a = 2. * 2. / 3. local real b = 2. / 3. * 2. call BJDebugMsg("a = " + R2S(a)) call BJDebugMsg("b = " + R2S(b)) endfunction

Вообще-то можно было поставить точку только в первом числе, а остальные преобразовались бы по цепочке. Тип real можно сравнить с зомби, он «заражает» значения с типом integer через операции. Потому, что, как я уже писал, если при выполнении арифметической операции хотя бы одно значение имеет тип real, то в результате получится число с типом real.

Теперь исправим пример с типом integer, чтобы обе переменные были равны 1:
Скопировать в буфер

function Test takes nothing returns nothing local integer a = 2 * 2 / 3 local integer b = R2I(2. / 3. * 2.) call BJDebugMsg("a = " + I2S(a)) call BJDebugMsg("b = " + I2S(b)) endfunction

В общем, не то чтобы это какое-то важное знание, но иногда нужно быть внимательным к таким деталям.

Точность

Уточню, под точностью имеются в виду не случайные колебания или ошибки, никаких случайностей и ошибок в вычислениях нет. Под точностью имеется в виду доступное для вычислений количество знаков. Например, в математике выражение 1/3 + 1/3 + 1/3 равно 1. Три трети, это одно целое. Но теперь представьте, что вы должны использовать только десятичные дроби при расчетах и к тому же вам доступно только три знака после точки. Тогда 1/3 будет равно 0.333, а всё выражение 0.333 + 0.333 + 0.333 = 0.999, а это уже не единица. В джассе всё немного иначе, но смысл примерно тот же.

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

Для начала узнаем, как устроен тип real. Компьютер не может хранить и вычислять бесконечные числа, все числа имеют ограниченное количество знаков. В нашем случае и integer, и real состоят из 32 битов. Я не хочу всё усложнять и рассказывать вам о том, что такое двоичная система счисления. Если хотите, ищите статьи сами, но это знание не сильно поможет вам в создании карт. Поэтому лучше представьте, что у вас есть по 6 знаков на число. Число 6 взято для удобства и в нем нет никакого смысла, а 32 бита это тоже 32 знака, но только в двоичной системе счисления. Возьмем, например число 356, запишем его используя 6 знаков и получим 000356. Это было целое число, а что если нам нужно дробное число, например, 3.5? Мы можем использовать три знака для целой части и три знака для дробной, получится 003.500. А еще мы можем передвигать точку в зависимости от нужд, при этом изменяя доступное число знаков для дробной и целой части. Например: 4355.55, 0.06243, 324323., .000001. Ну, вы поняли, точка как-бы “плавает”, а такое число называют числом с плавающей точкой.

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

Прежде чем продолжить, познакомимся с такой нативной функцией:

native R2SW takes real r, integer width, integer precision returns string

где r – число, которое мы преобразовываем в строку,
width – минимальное количество знаков до точки (недостающие знаки будут пробелами),
precision – количество знаков после точки (недостающие знаки будут нулями)

Данная функция преобразовывает число типа real в строку (тип string). В отличие от похожей функции R2S, которая показывает только три знака после точки, функция R2SW принимает дополнительные аргументы и может показывать больше или меньше знаков после точки.

А теперь запустим такую функцию:
Скопировать в буфер

function TestReal takes nothing returns nothing local real a = 444444. + 0.22222222 local real b = 4444. + 0.22222222 local real c = 44. + 0.22222222 call BJDebugMsg(R2SW(a, 0, 8)) call BJDebugMsg(R2SW(b, 0, 8)) call BJDebugMsg(R2SW(c, 0, 8)) endfunction

Вывод на экран:
Скопировать в буфер

444444.21875000 4444.22216796 44.22222136

Если к первому числу добавить еще пару цифр к целой части, то дробная часть будет полностью вытеснена целой частью. А эти непонятно откуда взявшиеся числа, которые мы видим там, где должны быть двойки, это наша следующая проблема. Она связана как раз таки с двоичной системой счисления, я не смогу объяснить причину простыми словами, поэтому и не буду. Просто нужно привыкнуть к тому, что при любых операциях с типом real могут получиться мелкие ошибочки. А еще эти ошибки способны накапливается в переменных. Ничего страшного в этом нет, но стоит запомнить лишь одну вещь, нельзя строго сравнивать значения с типом real. Это значит, что не стоит использовать операции равно (==) и не равно (!=) имея дело с типом real. Потому, что из-за этих мелких колебаний значения типа real не всегда бывают одинаковыми, когда вы этого ожидаете. Лучше напишите такую функцию для сравнения значений с типом real:

Скопировать в буфер

function IsEqualReal takes real a, real b, real eps returns boolean if (a - b >= 0) then return a - b 

function B2S takes boolean b returns string if (b) then return "true" else return "false" endif endfunction function IsEqualReal takes real a, real b, real eps returns boolean if (a - b >= 0) then return a - b 

1.5 равно 2 при разнице 0.5 - true -0.5 равно 0.5 при разнице 1 - true 0.0005 равно 0 при разнице 0.01 - true -2 равно -4 при разнице 2 - true 1.5 не равно 2 при разнице 0.25 - false -0.5 не равно 0.5 при разнице 0.5 - false 0.0005 не равно 0 при разнице 0.0001 - false