int что такое в информатике

Integer и int

В этом топике я хочу описать некоторые базовые различия между примитивными типами и соответствующими им объектными на примере int и Integer. Различия эти достаточно простые и, если немного задуматься, то вполне логичные, но, как показал опыт, программист не всегда над этим задумывается.

Основное различие, разумеется, в том, что Integer — это полнофункциональный объект, который занимает место в куче, а в коде вы пользуетесь ссылками на него, которые неявно преобразуются в значения:

Однако в большинстве случаев создаётся новый объект, и это может быть существенно. Помните так же, что объект Integer никогда не меняет своего значения. Рассмотрим такой на первый взгляд невинный код:

public class Increment
<
public static void main (String[] args)
<
Integer a= 0 ;
while(true) a++;
>
>

Попрофилируем использование памяти, к примеру, триальной версией JProfiler’а:

Очевидно, при каждом инкременте создаётся новый объект Integer, а старые затем подчищаются сборщиком мусора, когда их накапливается порядка ста тысяч. Неплохая нагрузка на систему для обычной операции инкремента.

В целом понятно, что Integer надо использовать только тогда, когда без него не обойтись. Один из таких примеров — это параметризованные типы (generics), к примеру, стандартные коллекции. Но и тут надо быть аккуратным, чтобы использовать память разумно. Я приведу несколько утрированный пример на основе проблемы, с которой я столкнулся в реальном проекте. В некотором научном анализе требовалось ассоциировать с определёнными объектами длинные множества натуральных чисел. Можно сэмулировать это следующим кодом:

public class MapInteger
<
static Map > subSets = new HashMap >();

public static void put (Integer key, int value)
<
if(!subSets. containsKey (key)) subSets. put (key, new HashSet ());
subSets. get (key). add (value);
>

public static Collection getRandomKeys ()
<
List vals = new ArrayList ();
for( int i= 0 ; i int )(Math. random ()* 500 ); i++)
<
vals. add (( int )(Math. random ()* 1000 ));
>
return vals;
>

public static void main (String[] args)
<
new Scanner(System. in ). nextLine ();
for(Integer i= 0 ; i 100000 ; i++)
<
for(Integer key: getRandomKeys ())
put (key, i);
>
new Scanner(System. in ). nextLine ();
>
>

Для каждого числа из первых ста тысяч мы определяем набор ключей с помощью getRandomKeys (в реальной задаче ключи, конечно, были неслучайны) и добавляем текущее число в соответствующие множества subSets. Тип ключей Integer выбран для упрощения иллюстрации; в целом он неважен. Вот количества объектов до выполнения операции:

А вот после:

Принудительный запуск сборщика мусора помог несильно:

40 мегабайт памяти съедают целые числа — это печально. Причина кроется в прототипе метода put:
public static void put(Integer key, int value)
Из-за того, что здесь использован тип int, значения переменной i при передаче в метод автоматически преобразуются в int (unboxing), а затем заново в Integer (boxing), но уже создаётся новый объект. Заменим в прототипе int value на Integer value и запустим профайлер заново. В начале картина такая же:

Зато в конце значительные отличия:

И после сборки мусора:

Так, заменив один int на Integer, можно сэкономить около 40% используемой памяти. Заметим, что в for(Integer i=0; i тоже неслучайно используется Integer: напишем здесь int, и первое исправление не поможет. Видим, что правило писать int везде, где можно не писать Integer, работает не всегда: в каждом отдельном случае надо думать. Иногда также может пригодиться собственная реализация кэша целых чисел.

Источник

Целое (тип данных)

Содержание

Представление

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

Для 64-разрядных операционных систем учитывая разность моделей данных (LP64, LLP64, ILP64), представление целого типа на разных моделях данных может отличаться между собой. Тип int и long может составлять как 4 так и 8 байт.

Стоит отметить, что каждый язык программирования реализует свою сигнатуру представления целых чисел, которая может отличатся от международных стандартов, но обязана его/их поддерживать. К примеру можно отнести кросс-платформенную библиотеку Qt, где целое представляется типом qintX и quintX, где X-8,16,32,64.

Целые типы подразделяются на беззнаковые (англ. unsigned ) и знаковые (англ. signed ).

Беззнаковые целые

В C и C++ для обозначения беззнаковых типов используется префикс unsigned. В C# в качестве показателя беззнаковости используется префикс u (англ. unsigned). Например, для объявления беззнакового целого, равного по размеру одному машинному слову используется тип uint.

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

Иногда в литературе [1] встречаются рекомендации не использовать тип беззнаковые целые, поскольку он может быть не реализован процессором компьютера, однако вряд ли этот совет следует считать актуальным — большинство современных процессоров (в том числе x86-совместимые [2] ) одинаково хорошо работают как со знаковыми, так и с беззнаковыми целыми.

В некоторых языках, например java, беззнаковые целые типы (за исключением символьного) отсутствуют. [3]

Целые со знаком

Предельные значения для разных битностей

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

Операции над целыми

Арифметические операции

К целочисленным значениям применимы в первую очередь арифметические операции. Ниже приведены самые часто используемые (в скобках указаны их обозначения в различных языках программирования и им аналогичным средствах).

В некоторых языках программирования для лаконичности есть операторы, которые позволяют производить арифметическую операцию с присвоением. Например, «+=» складывает текущее значение переменной слева с выражением справа и помещает результат в исходную переменную. Так же в некоторых языках и средах доступна совмещённая операция MulDiv, которая умножает на одно число, а потом делит результат на второе.

Обычно самыми дорогими по скорости операциями являются умножение и деление (получение остатка от деления).

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

Побитовые операции

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

Работа со строками

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

Ниже перечислены некоторые из представлений чисел строкой.

Перечислимый тип

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

Источник

Целые типы

Во Free Pascal определен ряд целых типов, различающихся между собой объемом отводимой под данные памяти. Чем больше памяти отводится, тем больший диапазон значений может принимать переменная данного типа.

На практике часто используется целочисленный тип integer, под который в зависимости от платформы отводится 2 или 4 байта.

Примеры часто используемых целых типов в Pascal

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

Целочисленные переменные в программе описываются следующим образом:

Операции над целыми типами, дающие в результате значение целого типа:

Пример. Пусть a = 17, b = 5. Тогда a div b дает 3, a mod b дает 2 (остаток от деления).

Операции над операндами целого типа выполняются правильно только при условии, что результат и каждый операнд не меньше минимального (крайнего левого) и не больше максимального (крайнего правого) значений диапазона. Например, в Паскале существует константа maxint, в которой содержится максимально допустимое значение для типа integer. Тогда при выполнении операций в программе должны соблюдаться следующие условия:

Процедуры inc и dec изменяют значение переданной в них переменной, они ничего не возвращают в программу. Это их важное отличие от функций succ и pred.

Следующие функции принимают в качестве аргументов значения вещественного типа, а возвращают значения целого типа:

trunc(x) – отбрасывание десятичных знаков после точки;
round(x) – округление до целого.

Пример. Пусть x = 4.7389. Тогда trunc ( x ) дает 4, round ( x ) дает 5.

Источник

Урок №31. Целочисленные типы данных: short, int и long

Обновл. 11 Сен 2021 |

На этом уроке мы рассмотрим целочисленные типы данных в языке С++, их диапазоны значений, операцию деления, а также переполнение (что это такое и примеры).

Целочисленные типы данных

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

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

Объявление целочисленных переменных

Объявление происходит следующим образом:

Диапазоны значений и знак целочисленных типов данных

Как вы уже знаете из предыдущего урока, переменная с n-ным количеством бит может хранить 2 n возможных значений. Но что это за значения? Это значения, которые находятся в диапазоне. Диапазон — это значения от и до, которые может хранить определенный тип данных. Диапазон целочисленной переменной определяется двумя факторами: её размером (измеряется в битах) и её знаком (который может быть signed или unsigned).

Целочисленный тип signed (со знаком) означает, что переменная может содержать как положительные, так и отрицательные числа. Чтобы объявить переменную как signed, используйте ключевое слово signed :

По умолчанию, ключевое слово signed пишется перед типом данных.

В некоторых случаях мы можем заранее знать, что отрицательные числа в программе использоваться не будут. Это очень часто встречается при использовании переменных для хранения количества или размера чего-либо (например, ваш рост или вес не может быть отрицательным).

Целочисленный тип unsigned (без знака) может содержать только положительные числа. Чтобы объявить переменную как unsigned, используйте ключевое слово unsigned :

1-байтовая целочисленная переменная без знака (unsigned) имеет диапазон значений от 0 до 255.

Обратите внимание, объявление переменной как unsigned означает, что она не сможет содержать отрицательные числа (только положительные).

Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Для нематематиков: Используем таблицу 🙂

Начинающие программисты иногда путаются между signed и unsigned переменными. Но есть простой способ запомнить их различия. Чем отличается отрицательное число от положительного? Правильно! Минусом спереди. Если минуса нет, значит число — положительное. Следовательно, целочисленный тип со знаком (signed) означает, что минус может присутствовать, т.е. числа могут быть как положительными, так и отрицательными. Целочисленный тип без знака (unsigned) означает, что минус спереди отсутствует, т.е. числа могут быть только положительными.

Что используется по умолчанию: signed или unsigned?

Так что же произойдет, если мы объявим переменную без указания signed или unsigned?

Все целочисленные типы данных, кроме char, являются signed по умолчанию. Тип char может быть как signed, так и unsigned (но, обычно, signed).

В большинстве случаев ключевое слово signed не пишется (оно и так используется по умолчанию).

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

Правило: Используйте целочисленные типы signed, вместо unsigned.

Переполнение

Вопрос: «Что произойдет, если мы попытаемся использовать значение, которое находится вне диапазона значений определенного типа данных?». Ответ: «Переполнение».

Переполнение (англ. «overflow») случается при потере бит из-за того, что переменной не было выделено достаточно памяти для их хранения.

На уроке №28 мы говорили о том, что данные хранятся в бинарном (двоичном) формате и каждый бит может иметь только 2 возможных значения ( 0 или 1 ). Вот как выглядит диапазон чисел от 0 до 15 в десятичной и двоичной системах:

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

Примеры переполнения

Рассмотрим переменную unsigned, которая состоит из 4 бит. Любое из двоичных чисел, перечисленных в таблице выше, поместится внутри этой переменной.

«Но что произойдет, если мы попытаемся присвоить значение, которое занимает больше 4 бит?». Правильно! Переполнение. Наша переменная будет хранить только 4 наименее значимых (те, что справа) бита, все остальные — потеряются.

Например, если мы попытаемся поместить число 21 в нашу 4-битную переменную:

Число 21 занимает 5 бит (10101). 4 бита справа (0101) поместятся в переменную, а крайний левый бит (1) просто потеряется. Т.е. наша переменная будет содержать 0101, что равно 101 (нуль спереди не считается), а это уже число 5, а не 21.

Теперь рассмотрим пример в коде (тип short занимает 16 бит):

Результат выполнения программы:

x was: 65535
x is now: 0

Что случилось? Произошло переполнение, так как мы попытались присвоить переменной x значение больше, чем она способна в себе хранить.

Для тех, кто хочет знать больше: Число 65 535 в двоичной системе счисления представлено как 1111 1111 1111 1111. 65 535 — это наибольшее число, которое может хранить 2-байтовая (16 бит) целочисленная переменная без знака, так как это число использует все 16 бит. Когда мы добавляем 1, то получаем число 65 536. Число 65 536 представлено в двоичной системе как 1 0000 0000 0000 0000, и занимает 17 бит! Следовательно, самый главный бит (которым является 1) теряется, а все 16 бит справа — остаются. Комбинация 0000 0000 0000 0000 соответствует десятичному 0, что и является нашим результатом.

Аналогичным образом, мы получим переполнение, использовав число меньше минимального из диапазона допустимых значений:

Результат выполнения программы:

x was: 0
x is now: 65535

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

Правило: Никогда не допускайте возникновения переполнения в ваших программах!

Деление целочисленных переменных

В языке C++ при делении двух целых чисел, где результатом является другое целое число, всё довольно предсказуемо:

Но что произойдет, если в результате деления двух целых чисел мы получим дробное число? Например:

В языке C++ при делении целых чисел результатом всегда будет другое целое число. А такие числа не могут иметь дробь (она просто отбрасывается, не округляется!).

Правило: Будьте осторожны при делении целых чисел, так как любая дробная часть всегда отбрасывается.

Поделиться в социальных сетях:

Урок №30. Размер типов данных

Комментариев: 23

Всем доброго времени суток. Появился такой вопрос: для объявления без знакового числа, для плюсов, обязательно писать unsigned int X, есть ли сокращенная форма по типу uint X?

Может проще для запоминания было сказать, что тип signed (со знаком) использует 1 (старший бит в байте для записи этого самого знака и для самого числа остается 7 бит (это в случае 1-го байта, для 2- байт 15 и т.д.) и в 7 битах можно записать число не больше чем 128.
К примеру 10000000 это отрицательный ноль. 🙂 Но такого не бывает.

Для того, чтоб числа имели дробь при делении целых чисел можно приписать ноль после точкой. Например : 8.0/5.0 = 1.6

Только это уже совсем другая история)

Достаточно поставить точку одному из выражений. Например: 8. / 5 или 8 / 5.

Остальное компилятор сам подставит)

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

Например, нужно много раз увеличивать переменную на 1 и циклически прокручивать все значения от 0 до 255. Писать условие «если равно 255, то присвоить 0» — совсем не нужно, это произойдёт само при прибавлении 1 к 255, если используется 1-байтовая беззнаковая.

Другой очень частый пример: вычисление разности двух значений миллисекундного таймера, чтобы замерить период времени. 4-байтовая переменная с таким таймером переполняется каждые 49 суток. Если система работает непрерывно, то такое может случаться. Когда считаем разность (новое значение таймера минус старое) — возможен случай, когда новое значение уже переполнилось (снова пошло с нуля), а старое ещё нет (огромное число). Но когда вычисляется разность, тут снова произойдёт переполнение (из-за того, что получилось отрицательное значение), и эти два переполнения оказывают взаимно компенсирующее действие, как будто их не было вообще. И разность всё равно будет верной. И не надо городить никаких хитрых алгоритмов.

Скорее всего это какой-то очень древний подход. Никогда не слышал подобного в универе.

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

unsigned используется для экономии памяти, это же очевидно. Если знак действительно не нужен за счет дополнительно освобожденного бита, можно увеличить диапазон значений в 2 раза, что в некоторых случаях позволит использовать более «экономные» типы данных.

Ну так нужно указывать другой тип переменной(не целое число). Тогда будет дробь.

Забавная история, почему этот урок так важен =)
В игре Civilization есть баг с механикой агрессии и миролюбия. Суть такова, что агрессивность цивилизации измерялась по шкале от 1 до 10. Девятки и десятки были у всяких Чингисханов, Монтесум и Сталиных, а у духовного пацифиста Махатмы Ганди была единичка. И ещё были модификаторы — строй «республика» уменьшает агрессивность на 1, «демократия» — на 2. Соответственно, сразу же, как только индусы открывали Демократию, у Ганди становилась агрессивность −1.

А теперь внимание. Эта переменная была однобайтная и строго неотрицательная(unsigned), от 0 до 255. Соответственно, агрессивность Махатмы Ганди становилась равна 255 из 10. Поэтому, построив у себя демократию, Ганди двигался рассудком, клепал ядрёные бомбы и умножал всех на ноль.

Действительно хороший пример 🙂 С unsigned нужно быть аккуратным.

Источник