Что такое переменная int
Урок №31. Целочисленные типы данных: short, int и long
Обновл. 11 Сен 2021 |
На этом уроке мы рассмотрим целочисленные типы данных в языке С++, их диапазоны значений, операцию деления, а также переполнение (что это такое и примеры).
Целочисленные типы данных
| Тип | Минимальный размер | |
| Символьный тип данных | char | 1 байт |
| Целочисленный тип данных | short | 2 байта |
| int | 2 байта (но чаще всего 4 байта) | |
| long | 4 байта | |
| long long | 8 байт |
Примечание: Тип 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 или unsigned (в большинстве случаев signed) |
| Целочисленный тип данных | short | signed |
| int | signed | |
| long | signed | |
| long long | signed |
Все целочисленные типы данных, кроме char, являются signed по умолчанию. Тип char может быть как signed, так и unsigned (но, обычно, signed).
В большинстве случаев ключевое слово signed не пишется (оно и так используется по умолчанию).
Программисты, как правило, избегают использования целочисленных типов unsigned, если в этом нет особой надобности, так как с переменными unsigned ошибок, по статистике, возникает больше, нежели с переменными signed.
Правило: Используйте целочисленные типы signed, вместо unsigned.
Переполнение
Вопрос: «Что произойдет, если мы попытаемся использовать значение, которое находится вне диапазона значений определенного типа данных?». Ответ: «Переполнение».
Переполнение (англ. «overflow») случается при потере бит из-за того, что переменной не было выделено достаточно памяти для их хранения.
На уроке №28 мы говорили о том, что данные хранятся в бинарном (двоичном) формате и каждый бит может иметь только 2 возможных значения ( 0 или 1 ). Вот как выглядит диапазон чисел от 0 до 15 в десятичной и двоичной системах:
| Десятичная система | Двоичная система |
| 0 | 0 |
| 1 | 1 |
| 2 | 10 |
| 3 | 11 |
| 4 | 100 |
| 5 | 101 |
| 6 | 110 |
| 7 | 111 |
| 8 | 1000 |
| 9 | 1001 |
| 10 | 1010 |
| 11 | 1011 |
| 12 | 1100 |
| 13 | 1101 |
| 14 | 1110 |
| 15 | 1111 |
Как вы можете видеть, чем больше число, тем больше ему требуется бит. Поскольку наши переменные имеют фиксированный размер, то на них накладываются ограничения на количество данных, которые они могут хранить.
Примеры переполнения
Рассмотрим переменную unsigned, которая состоит из 4 бит. Любое из двоичных чисел, перечисленных в таблице выше, поместится внутри этой переменной.
«Но что произойдет, если мы попытаемся присвоить значение, которое занимает больше 4 бит?». Правильно! Переполнение. Наша переменная будет хранить только 4 наименее значимых (те, что справа) бита, все остальные — потеряются.
Например, если мы попытаемся поместить число 21 в нашу 4-битную переменную:
| Десятичная система | Двоичная система |
| 21 | 10101 |
Число 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 нужно быть аккуратным.
Целочисленные типы (справочник по C#)
Целочисленные типы представляют целые числа. Все целочисленные типы являются типами значений. Они также представляют собой простые типы и могут быть инициализированы литералами. Все целочисленные типы поддерживают арифметические операторы, побитовые логические операторы, операторы сравнения и равенства.
Характеристики целочисленных типов
C# поддерживает следующие предварительно определенные целочисленные типы:
Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.
Целочисленные литералы
Целочисленные литералы могут быть:
В приведенном ниже коде показан пример каждого из них.
В предыдущем примере также показано использование _ в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7.0. Цифровой разделитель можно использовать со всеми видами числовых литералов.
Тип целочисленного литерала определяется его суффиксом следующим образом:
Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.
Как показано в предыдущем примере, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.
Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:
Преобразования
Любой целочисленный тип можно преобразовать в любой другой целочисленный тип. Если целевой тип может хранить все значения исходного типа, преобразование является неявным. В противном случае необходимо использовать выражение приведения для выполнения явного преобразования. Для получения дополнительной информации см. статью Встроенные числовые преобразования.
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
AVR GCC :: ПЕРЕМЕННЫЕ И КОНСТАНТЫ
Для хранения различных данных в языках программирования используют переменные. Переменной называется область памяти, имеющая имя, которое иначе называют идентификатором.
Давая переменной имя, программист одновременно тем же именем называет и область памяти, куда будут записываться значения переменной для хранения.
Хорошим стилем является осмысленное именование переменных. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква, в имени переменной не должно быть пробелов. В современных версиях компиляторов длина имени практически не ограничена. Имя переменной не может совпадать с зарезервированными ключевыми словами. Заглавные и строчные буквы в именах переменных различаются, переменные a и A — разные переменные.
В языке Си все переменные должны быть объявлены. Это означает, что, во-первых, в начале каждой программы или функции Вы должны привести список всех используемых переменных, а во-вторых, указать тип каждой из них.
При объявлении переменной компилятор отводит ей место в памяти в зависимости от её типа. Стандартными средствами AVR GCC работает с типами данных char (символьный тип) и int (целочисленный тип).
Ключевые слова (модификаторы) signed и unsigned указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый.
Целочисленная величина int может быть short (короткой) или long (длинной).
| Объявление переменных |
Переменные объявляют в операторе описания. Оператор описания состоит из спецификации типа и списка имён переменных, разделённых запятой. В конце обязательно должна стоять точка с запятой.
Объявление переменной имеет следующий формат:
Инициализация значения переменной при объявлении
При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение. Сделать это можно следующим образом. Таким образом, в переменную x при объявлении сразу же будет записано число 100.
Лучше избегать смешивания инициализируемых переменных в одном операторе описания, то есть инициализируемые переменные лучше объявлять в отдельных строках.
Для присваивания в Си служит знак «=». Выражение, стоящее справа от знака присваивания, вычисляется, и полученное значение присваивается переменной, стоящей слева от знака присваивания. При этом предыдущее значение, хранящееся в переменной, стирается и заменяется на новое.
Оператор «=» не следует понимать как равенство.
Например, выражение a = 5; следует читать как «присвоить переменной a значение 5».
Примеры:
В правой части значение переменной может использоваться несколько раз:
| Арифметические операции |
Арифметические операции записываются в выражениях следующим образом:
| + | плюс |
| — | минус |
| * | умножить |
| / | разделить |
Пример:
Таким образом, в переменной z будет храниться число 23
| Дополнительные способы присваивания |
Кроме простого оператора присваивания «=», в Си существует еще несколько комбинированных операторов присваивания: «+=», «-=», «*= Инкремент и декремент
Пример:
Инкремент и декремент относятся к операциям присваивания. При использовании декремента и инкремента совместно с оператором присваивания «=» применяют постфиксную (x++) или префиксную (++x) запись. Первой выполняется префиксная запись.
Переменные
Переменные
П еременные используются для хранения значений (sic!). Переменная характеризуется типом и именем. Начнём с имени. В си переменная может начинаться с подчерка или буквы, но не с числа. Переменная может включать в себя символы английского алфавита, цифры и знак подчёркивания. Переменная не должна совпадать с ключевыми словами (это специальные слова, которые используются в качестве управляющих конструкций, для определения типов и т.п.)
| auto | double | int | struct |
| break | else | long | switch |
| register | typedef | char | extern |
| return | void | case | float |
| unsigned | default | for | signed |
| union | do | if | sizeof |
| volatile | continue | enum | short | while | inline |
А также ряд других слов, специфичных для данной версии компилятора, например far, near, tiny, huge, asm, asm_ и пр.
Типы переменных
Целые
Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.
| Тип | Размер, байт | Минимальное значение | Максимальное значение |
|---|---|---|---|
| unsigned char | 1 | 0 | 255 |
| signed char ( char ) | 1 | -128 | 127 |
| unsigned short | 2 | 0 | 65535 |
| signed short ( short ) | 2 | -32768 | 32767 |
| unsigned int ( unsigned ) | 4 | 0 | 4294967296 |
| signed int ( int ) | 4 | -2147483648 | 2147483647 |
| unsigned long | 4 | 0 | 4294967296 |
| signed long ( long ) | 4 | -2147483648 | 2147483647 |
| unsigned long long | 8 | 0 | 18446744073709551615 |
| signed long long ( long long ) | 8 | -9223372036854775808 | 9223372036854775807 |
sizeof
В си есть оператор, который позволяет получить размер переменной в байтах. sizeof переменная, или sizeof(переменная) или sizeof(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.
(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще
В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned
Типы с плавающей точкой
Переполнение переменных
Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»
Вообще, поведение при переполнении переменной определено только для типа unsigned: Беззнаковое целое сбросит значение. Для остальных типов может произойти что угодно, и если вам необходимо следить за переполнением, делайте это вручную, проверяя аргументы, либо используйте иные способы, зависящие от компилятора и архитектуры процессора.
Постфиксное обозначение типа
Следующий код, однако, не будет приводить к ошибкам, потому что происходит неявное преобразование типа
Шестнадцатеричный и восьмеричный формат
В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:
Экспоненциальная форма представления чисел
Объявление переменных
При объявлении переменной пишется её тип и имя.
Можно объявить несколько переменных одного типа, разделив имена запятой
Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции
Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать
Начальное значение переменной
Область видимости переменной
П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная «видна в каком-то месте», это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная
Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример
Программа выведет 555. Также, как и в прошлом случае, локальная переменная «важнее». Переменная, объявленная в некоторой области видимости не видна вне её, например
Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга
Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое
Во-первых, глобальная переменная, если она видна всем, может быть изменена любой частью программы. Вы изменили глобальную переменную, хотите её записать, а другая часть программы уже перезаписала в неё другое значение (на самом деле это целый класс проблем, которые возникают в многопоточной среде). Во-вторых, при больших размерах проекта не уследить, кто и когда насоздавал глобальных переменных. В приведённых выше примерах видно, как переменные могут перекрывать друг друга, то же произойдёт и в крупном проекте.
Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.