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

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

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

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

Так как Lazarus использует компилятор Free Pascal, то всё сказанное о типах данных по отношению к Free Pascal справедливо и для Lazarus.

Итак, целочисленные типы данных Free Pascal перечислены в таблице 13.1.

Таблица 13.1. Целочисленные типы данных Free Pascal (Lazarus).

А теперь несколько пояснений к таблице.

В колонке ТИП приведены идентификаторы типов данных (ключевые слова, которые указывают компилятору, к какому типу относятся те или иные данные). Как использовать эти идентификаторы, вы узнаете в следующих уроках.

В колонке РАЗМЕР указан размер, который занимает тип данных в памяти компьютера. Например, целое положительное число можно представить разными типами: Byte, Word, Cardinal и др. Однако число типа Cardinal будет занимать в памяти 4 байта, в то время как число типа Byte – всего лишь 1 байт. Поэтому, если вы точно знаете, что число, с которым вы работаете, никогда не примет значение больше 255, то лучше определять его как тип Byte, так как это позволит сэкономить место в памяти компьютера. Хотя здесь не всё так однозначно (нюансы распределения памяти и других ресурсов компьютера выходят за рамки данного курса).

В колонке ДИАПАЗОН указан диапазон значений, которым оперирует тип данных. Например, число типа Byte может принимать значения от 0 до 255.

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

Стандартная функция Low определяет минимальное значение типа данных. Фунцкия High определяет максимальное значение. С функциями WriteLn и ReadLn вы уже немного знакомы. Более подробно о подпрограммах (процедурах и функциях) мы будем говорить в соответствующем разделе курса.

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

Free Pascal поддерживает четыре формата записи целого числа:

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

Создайте программу, которая выводит на экран диапазоны значений целых чисел (листинг 13.1). Откомпилируйте программу и запустите её. Убедитесь, что эти значения соответствуют указанным в таблице 13.1.

В исходном коде программы найдите строку, которая задаёт режим компиляции:

В этой строке вместо слова objfpc напишите слово tp. То есть итоговая строка должна выглядеть так:

Запустите программу. Посмотрите диапазон значений типа Integer. Сделайте выводы.

Учитесь думать как программист, то есть логически. Никто вам до пенсии не будет всё разжёвывать, как это делаю сейчас я. Надо привыкать думать самостоятельно. Иначе вы скатитесь к “обезьяньему принципу обучения”, и тогда ваши шансы стать классным программистом приблизятся к нулю. Чтобы помочь вам не скатиться на уровень “зубрёжки”, я буду периодически оставлять пробелы в вашем обучении, чтобы вы постарались сами додуматься до каких-то вещей.

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

Источник

Структура языка программирования

Содержание

Дополнительно

Классификация типов данных

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

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

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

Числовые типы данных

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

Исходя из машинного представления целого числа, в ячейке памяти из n бит может хранится 2 n для беззнаковых, и 2 n-1 для знаковых типов.

Рассмотрим теперь конкретные целочисленные типы в трёх языках.

У некоторых типов есть приписка «16 разрядов» или «32 разряда». Это означает, что в зависимости от разрядности операционной системы и компилятора данный тип будет находится в соответствующем диапазоне. По-этому, рекомендуется не использовать int, unsigned int, а использовать их аналоги, но уже жестко определенные, short, long, unsigned short, unsigned long.

В Java нет беззнаковых целочисленных типов данных.

Вещественные типы данных

Числа вещественного типа данных задаются в форме чисел с плавающей запятой.

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

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

Рассмотрим конкретные типы данных в наших трёх языках.

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

Символьный тип данных

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

Логический тип данных

Перечислимый тип данных

Во внутреннем представлении, это целочисленный тип данных, только здесь пользователь вместо числе использует заранее определенные строковые значения.

Чтобы прочувствовать эту концепцию, приведем пример на языке С++ (в С# и Java аналогично)

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

Массив

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

В языках программирования нельзя оперировать всем массивом, работают с конкретным элементом. Чтобы доступиться до него в трёх рассматриваемых нами языках используют оператор «[]».

Структура

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

Например, есть колесо автомобиля. У колеса есть диаметр, толщина, шина. Шина в свою очередь является структурой, у которой есть свои параметры: материал, марка, чем заполнена. Естественно, для каждого параметра можно создать свою переменную или константу, у нас появится большое количество переменных, которые, чтобы понять к чему они относятся, нужно в именах общую часть выделять. Имена будут нести лишнюю смысловую нагрузку. Получается запутанная история. А так мы определяем две структуры, а затем параметры в них.

Класс

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

Источник

Целочисленные типы (справочник по C#)

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

Характеристики целочисленных типов

C# поддерживает следующие предварительно определенные целочисленные типы:

Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.

Целочисленные литералы

Целочисленные литералы могут быть:

В приведенном ниже коде показан пример каждого из них.

В предыдущем примере также показано использование _ в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7.0. Цифровой разделитель можно использовать со всеми видами числовых литералов.

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

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.

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

Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:

Преобразования

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

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

Источник

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

Содержание

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

В памяти типовой компьютерной системы целое число представлено в виде цепочки битов фиксированного (кратного 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, которая умножает на одно число, а потом делит результат на второе.

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

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

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

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

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

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

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

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

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

Источник

Урок №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 нужно быть аккуратным.

Источник