Переменные и типы данных в программировании
Материал из Википедии — свободной энциклопедии
Переменная – это ячейка в оперативной памяти микроконтроллера, которая имеет своё уникальное название (а также адрес в памяти) и хранит значение соответственно своему размеру. К переменной мы можем обратиться по её имени или адресу и получить это значение, либо изменить его.
Зачем нужны переменные?
В переменной могут храниться промежуточные результаты вычислений, полученные “снаружи” данные (с датчиков, Интернета, интерфейсов связи) и так далее.
Размеры целочисленных типов в C++
Большинство реализаций C++ предоставляют по крайней мере 8, 16, 32 и 64-битные знаковые и беззнаковые целочисленные типы. Существуют потенциально неудобные неявные преобразования, споры о неопределенном поведении при переполнении, но по большей части эти языковые конструкции хорошо справляются с поставленными задачами.
Инновации в целочисленных типах
Тем не менее, есть место для инноваций. Предлагаю рассмотреть три новых семейства целочисленных типов, которые могли бы быть добавлены в C++.
Типы данных и их влияние на обработку данных
Типы данных в программировании определяются выбранным языком разработки и позволяют выделить пространство в памяти оборудования под функции, переменные и иные объекты исходного кода. Это оказывает влияние на особенности обработки данных.
Примеры типов данных в C
В языках программирования СИ поддерживаются различные типы данных, такие как int, double, float. Далее рассмотрим ближе типизацию в информатике и ее особенности в языке C.
Статические переменные
Особенности работы статических переменных
При объявлении локальной переменной как static она будет сохранять своё значение на протяжении работы программы, но область видимости останется локальной: взаимодействовать с переменной можно будет только внутри блока кода, где она создана (и во всех вложенных в него).
Статические переменные позволяют более красиво организовывать код, избавляясь от лишних глобальных переменных.
Видео
Видео 1
Видео 2
Переменные, константы const и другие создаваемые пользователем данные имеют такое важное понятие, как область видимости. Она бывает глобальной и локальной.
### Глобальная
Важный момент: если имя локальной переменной совпадает с одной из глобальных, то приоритет обращения отдаётся локальной переменной (в её области определения).
## Полезные страницы
Можно объявить и инициализировать несколько переменных через запятую:
byte myVal;
int sensorRead = 10;
byte val1, val2, val3 = 10;
## Подкатегории
В этой категории отображается 8 подкатегорий из имеющихся 8.
Де-факто представление знаковых целых чисел на современном аппаратном уровне решается как дополнительный код (two’s complement). У положительных значений старший бит равен нулю, а у отрицательных — единице. Чтобы получить абсолютное значение отрицательного числа, инвертируйте все биты и прибавьте единицу.
Например, для 8-битного целого числа 42 — это 0b00101010: знаковый бит нулевой, остальные представляют 42 в двоичном формате. С другой стороны, -42 — это 0b11010110: если инвертировать все биты, то получится 0b00101001, прибавить единицу и снова 0b00101010, то есть, получится 42. Важно отметить, что 0b11111111 равно -1, а более глубокие отрицательные значения доходят до 0b10000000, что равно -128.
Заметили что-то интересное в последнем значении? Если вы выполните преобразование, то при инвертировании получите 0b01111111, а прибавление единицы приведет к 0b10000000 — переполнение в знаковом бите.
Это означает, что абсолютное выражение наименьшего значения больше абсолютного выражения наибольшего значения 0b01111111 или 127; отрицательных значений больше, чем положительных, потому что положительная половина, где бит знака не установлен, также содержит число ноль.
Мне очень не нравится эта асимметрия — она приводит к проблемным побочным явлениям во всех видах целочисленных API.
Для начала, abs(x) для целых чисел x не является тотальной функцией: abs(INT_MIN) не представима. Аналогично, x * (-1) тоже не является тотальной функцией: INT_MIN * (-1) переполняется. Еще забавнее становится в случае с делением: конечно, x / y не может переполниться, так как деление уменьшает значение, верно? Неверно, INT_MIN / (-1) переполняется (и выдает ошибку деления на ноль (!) на x86). Более того, INT_MIN % (-1) также приводит к неопределенному поведению.
Итак, вот чего я хочу: знаковое целое число, где INT_MIN == -INT_MAX, полученное путем перемещения минимального значения на единицу вверх.
Во-первых, вы не теряете ничего полезного: Я бы сказал, что дополнительное отрицательное число не имеет значения в большинстве случаев. В конце концов, если бы у вас было лишнее число, разве не логичнее было бы иметь дополнительное положительное число вместо отрицательного?
Во-вторых, вы восстанавливаете симметрию. Все операции, упомянутые выше, теперь симметричны и не могут переполняться. Так они становятся гораздо понятнее.
Добавление контрольного значения INT_NAN в целочисленную арифметику
Введение
В-третьих, вы получаете неиспользуемый битовый паттерн 0b10000000, старый INT_MIN, который вы можете интерпретировать как угодно. Хотя в принципе вы можете превратить его в какой-нибудь отрицательный ноль для дополнительной симметрии, пожалуйста, не делайте этого (вместо этого просто используйте дополнение единицы или знак величины).
Не число INT_NAN
Вместо этого мы должны скопировать другую функцию, относящуюся к арифметике с плавающей запятой: not-a-number (не число) или NaN. Назовем её INT_NAN = 0b10000000.
Как и NaN с плавающей запятой, INT_NAN не является допустимым целочисленным значением. В идеальном мире оно также было бы липким битом, так что INT_NAN ¤ x == INT_NAN, но для эффективной работы с ним требуется аппаратная поддержка. Вместо этого, давайте просто скажем, что арифметика на INT_NAN – это неопределенное поведение; тогда программа очистки, работая в режиме отладки, может проверить это, вставляя тестовые утверждения.
Преимущества использования INT_NAN
Почему я хочу INT_NAN и, таким образом, добавляю дополнительное предусловие ко всей целочисленной арифметике? Потому что мне очень нравятся контрольные значения. Например, с INT_NAN можно иметь sizeof(std::optional) == int. Вместо того, чтобы хранить дополнительное логическое число для отслеживания, существует ли опция, мы можем просто хранить INT_NAN. Аналогично, закрытая хэш-таблица должна каким-то образом различать пустые и непустые записи. Наличие контрольного значения позволяет обойтись без дополнительных метаданных.
Использование INT_NAN
Теперь вам может не понравиться, что мы решили работать с контрольным значением. Что если вы хотите хранить INT_NAN в std::optional? Ну, INT_NAN — это не число, так почему вы хотите хранить его в int? Только если вам нужно какое-то самостоятельное значение. Это похоже на контейнер NaN для значений с плавающей запятой — вы теряете возможность хранить (большинство) NaN, но повышаете эффективность хранения. Однако, в отличие от арифметики с плавающей точкой, где, например, 0/0 может привести к NaN, в моей модели ни одна арифметическая операция над целыми числами не может привести к INT_NAN, поскольку переполнение является неопределенным поведением. Поэтому вам действительно нужно избавиться от операций присваивания INT_NAN, чтобы ввести в код целочисленные NaN.
[Будьте внимательны с использованием INT_NAN в вашем коде.]
Вам может не понравиться, что я предлагаю арифметику на INT_NAN сделать неопределенным поведением, если вы в прошлом попадали под агрессивную оптимизацию компилятора. Однако НП в стандарте само по себе не является чем-то плохим; НП буквально означает, что в стандарте не предъявляется никаких требований к поведению, что обеспечивает максимальную свободу компилятору.
Можно исходить из того, что такого не происходит, выстраивая оптимизацию соответствующим образом, но также можно вставлять отладочные утверждения (либо отлавливающие все, либо обеспечивающие жесткие проверки с ложными отрицаниями), либо задать компилятору четко определенное поведение. Большинство распространённых компиляторов по умолчанию выбирают первую интерпретацию, но, например, я сейчас работаю над интерпретатором языка C, где компилятор будет выдавать панику во всех случаях неопределённого поведения.
## Преобразование типов
Иногда требуется преобразовать один тип данных в другой: например, функция принимает int, а вы хотите передать ей byte. В большинстве случаев компилятор сам разберётся и преобразует byte в int, но иногда вылетает ошибка в стиле “попытка передать byte туда, где ждут int“. В таком случае можно преобразовать тип данных, для этого достаточно указать нужный тип данных в скобках перед преобразуемой переменной (тип_данных)переменная, иногда можно встретить запись тип_данных(переменная).
Результат вернёт переменную с новым типом данных, сам же тип данной у переменной не изменится. Например:
// переменная типа byte
byte val = 10;
// передаём какой-то функции, которая ожидает int
sendVal( (int)val );
И всё! val будет обрабатываться как int, а не как byte.
## Типы данных
Последнее обновление: 24.01.2024
Переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная и сколько байт в памяти она будет занимать. В Си определены следующие базовые типы данных:
### Целочисленные типы
Наиболее распространенным целочисленным типом является int (имеет псевдонимы signed и signed int), представляет целое число со знаком и обычно занимает 4 байта.
Переменной такого типа можно передать целое число:
```c
int age = 38;
signed int number = 2;
signed temps = -3;
Для определения переменной некоторого типа можно использовать все псевдонимы этого типа. Так, в примере выше определяются три переменных типа int, хотя в каждом случае используются разные псевдонимы типа: int, signed int и signed.
Суффиксы целочисленных типов
Стоит учитывать, что любое десятичное число рассматривается по умолчанию как значение типов int/long int/long long int (в зависимости от размера) и при присвоении переменным другим типов будет выполняться преобразование.
Чтобы указать, что число явным образом представляет определенный тип, к числу добавляется определенный суффикс:
unsigned long int и unsigned long long int или
Как видно, не для всех типов есть отдельные суффиксы. И для некоторых типов можно применять несколько суффиксов. Применим суффикс. Например, если надо хранить только положительные числа, то можно взять тип . Для определения чисел этого типа применяется суффикс или :
При выводе таких чисел на консоль применяется спецификатор .
Стоит отметить, что мы могли бы присвоить переменной число и без суффикса и получили бы тот же самый результат:
unsigned number1 = 4294967294; // без суффикса u unsigned int number2 = 22; // без суффикса u printf("number1 = %u ", number1); printf("number2 = %u ", number2);
Зачем же нужен данный суффикс? Без этого суффикса десятичное число рассматривается как значение типов int/long int/long long int и при присвоении переменной типа unsigned int выполняется преобразование. Используя суффикс, мы можем избежать ненужного преобразования.
Пример определения данных других типов:
Обратите внимание на спецификатор, который используется для вывода числа на консоль в функции printf():
Определение чисел в различных системах
Си позволяет определять числа в разных числовых системых. Числа в двоичной системе начинаются с символов , после которых идет набор 1 и 0, которые представляют число. Восьмеричные числа начинаются с числа 0, за которым могут идти цифры от 0 до 7. Щестнадцатеричные числа начинаются с или , за которыми следуют шестнадцатеричные цифры от 0 до 9 и от A до F. Например:
В данном случае определены четыре переменных, но каждая из них хранит одно и то же число – 11, записанное в разных системах исчисления.
Числа с плавающей точкой
Числа с плавающей точкой представлены тремя типами: , , . В качестве разделителя между целой и дробной частями применяется точка. По умолчанию все дробные числа представляют тип , который занимает 8 байт:
Для вывода значения double на консоль используется спецификаторы и . Чтобы указать, что число представляет тип , применяется суффикс , а для – суффикс :
Стоит отметить, что для вывода данных типа на консоль применяется спецификатор , однако на некоторых платформах он может работать некорректно, например, показывать 0.
Символы
Переменным типа можно присвоить один символ в одинарных кавычках:
char letter = ‘A’;
Здесь определяется переменная letter, которая хранит символ ‘A’. Однако в реальности переменная типа char хранит число. И когда переменной присваивается символ, она получает числовой код этого символа из таблицы, которая сопоставляет числовые коды и символы. Наиболее распространена таблица ASCII. Она сопоставляет символы с числами от 0 до 127. Например, возьмем выше определенную переменную letter и выведем ее содержимое на консоль:
Числовой код символа ‘A’ в таблице ASCII равен 65. Для наглядности в программе два раза выводим значение переменной letter. Но в первом случае используем спецификатор %d для вывода числового кода символа, а во втором случае применяется спецификатор %c, который позволяет вывести на консоль сам символ. То есть при выполнении программа выведет на консоль:
Вместо символа в одинарных кавычках мы могли бы присвоить напрямую числовой код:
И мы получили бы тот же самый результат.
Typedef
Оператор позволяет определить для определенного типа псевдоним. Это может потребоваться, например, когда название некоторого типа довольно большое, и мы хотим его сократить.
Общая форма оператора
typedef существующий_тип псевдоним
Например, зададим для типа unsigned char псевдоним BYTE:
typedef unsigned char BYTE;
И мы сможем использовать этот тип как и любой другой:
Размер типов данных
В выше приведенном списке для каждого типа указан размер, который он занимает в памяти. Однако стоит отметить, что предельные размеры для типов разработчики компиляторов могут выбирать самостоятельно, исходя из аппаратных возможностей компьютера. Стандарт устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение – 16 бит, для типа long – 32 бита. При этом размер типа long должен быть не меньше размера типа int, а размер типа int – не меньше размера типа short. Но в целом для типов используются те размеры, которые указаны выше при описании типов данных.
Однако бывают ситуации, когда необходимо точно знать размер определенного типа. И для этого в C есть оператор , который возвращает размер памяти в байтах, которую занимает переменная:
sizeof(number) = 4
При этом при определении переменных важно понимать, что значение переменной не должно выходить за те пределы, которые очерчены для ее типа. Например:
unsigned short int number = -65535;
Компилятор GCC при компиляции программы с этой строкой выдаст ошибку о том, что значение -65535 не входит в диапазон допустимых значений для типа unsigned short int.
Страницы в категории «Типы данных»
Показано 58 страниц из 58, находящихся в данной категории. Список ниже может не отражать последних изменений.
Источник — https://ru.wikipedia.org/w/index.php?title=Категория:Типы_данных&oldid=133859225
Различные битовые векторы в сравнении с целочисленным типом
Недавно я работал над компилятором для языка, в котором различаются целочисленные типы со знаком, беззнаковые целочисленные типы и битовые целочисленные типы. Первые два семейства поддерживают только арифметические операции, и только последнее поддерживает битовые операции. Сначала я был настроен скептически, но потом мне очень понравилось это различие.
Мне всегда казалось странным, что мы относимся к целочисленному типу как к числу и выполняем над ним арифметические действия, одновременно изменяя отдельные разряды. Когда вы занимаетесь математикой, вам редко приходится оперировать отдельными цифрами! Это особенно верно для знаковых целых чисел, где знаковый бит всё портит и приводит к определенному или неопределенному поведению при операциях сдвига.
Конечно, разделение этих двух операций делает написание таких оптимизаций, как shift вместо division или bitwise and вместо modulo, более назойливым, а некоторые причудливые битовые уловки требуют больше приведений. Но, в то же время, так становится очевиднее, что именно происходит: мы начинаем рассматривать целое число как последовательность битов. Так приобретается некоторый выигрыш в производительности, но это требуется дополнительно документировать.
Беззнаковые целые числа без одного бита
Использование беззнаковых целочисленных типов в C++ — дело, мягко говоря, спорное. «За» такой подход возможность выразить в системе типов тот факт, что некоторая сущность не может быть отрицательной. Аргументом «против» является тот факт, что вычитание легко приводит к возникновению больших значений из-за целочисленного переполнения при нуле.
Сделаю отступление и отмечу, что это не «целочисленное переполнение через нижнюю границу». — это не выход. Преодоление минимального значения целого числа — это все равно целочисленное переполнение. Антипереполнение происходит, когда у вас есть число, которое слишком близко к нулю, чтобы быть представленным в виде плавающей точки.
Будучи сторонником беззнаковых целочисленных типов, я не могу возразить против неудобного переполнения при вычитании. Да, оно может вызывать всевозможные неприятные ошибки, начиная от переполнения буфера и заканчивая ошибками «out of memory». Переход на знаковые целые целесообразен, поскольку сильно отрицательное значение очевидно вскрывает факт ошибки. Также с такой позиции выступают многие, кто использует знаковое значение на все случаи жизни. Стыдно так делать, поскольку так вы теряете возможность выражать что-либо в системе типов.
Поскольку во многих ситуациях дополнительный бит памяти, очевидно, не нужен, я хотел бы иметь нечто, что логически является 63-битным беззнаковым целым числом, а не 64-битным. В ассемблере такая сущность представляется так же, как 64-битное знаковое целое число. Однако, если в ней когда-либо сохранится отрицательное значение, это будет неопределенным поведением. Всё точно как с булевым значением: логически это один бит, но физически он представлен как байт.
Представляется, что это равноценно знаковому целому числу с более многочисленными вариантами НП, так стоит ли этим заниматься?
Во-первых, по сравнению с int, такая сущность автоматически поставляется с предварительным условием, что число не может быть отрицательным. Во-вторых, в режиме отладки требуется меньше проверок на переполнение. Поскольку у нас широкий диапазон недопустимых значений, мы можем просто проверять значение всякий раз, когда выполняем операцию сохранения, а не после каждой арифметической операции. Конечно, программа может переполниться в промежуточном выражении, тогда затем можно отменить переполнение в последующих арифметических операциях, но это хороший компромисс между производительностью и безопасностью.
Опять же, подобная слабая отладочная проверка была бы невозможна, если бы стандарт требовал завершения программы при переполнении.
Фактически, эти беззнаковые целочисленные типы на практике в точности эквивалентны соответствующим знаковым целочисленным типам с гарантией, что число неотрицательно, когда это необходимо. Этот аспект просто встроен в систему типов и реализуется компилятором, программисту не требуется прописывать такое предусловие.
Единицы измерения
Когда стало понятно, что означает типизация, а также какими условно бывают виды информации, некоторые из них (double и другие) могут быть изучены более подробно. Сначала нужно выяснить, в каких единицах измеряются данные в IT и информатике.
Минимальная единица измерения – это бит. Оно выражает информацию, которая выступает достаточно для установки различий между двумя явлениями одинаковой вероятности. 1 бит указывает на два понятия 0 и 1 (ложь и истина, неверно или верно, нет или да, zero или определенное значение).
Бит – самая маленькая единица измерения, с которой может работать оператор или функция. Она редко используется на практике. Чаще всего программистам приходится работать с другой единицей измерения – с байтами. 1 byte – это 8 бит.
Вот единицы измерения количества данных и их диапазон. Они представлены по возрастанию:
По представленному выше принципу обозначена измерительная система, которая является международным стандартом. В программировании при выяснении того, какой размер имеет функция или переменная, принято применять биты или байты. В них переводятся остальные единицы счисления.
Когда стало понятно, каким образом в информатике определяется размер (size) в файле или документе, а также ключевые единицы счисления в IT, можно более подробно изучить основные виды информации в C. К ним относят значение переменной типа «простое».
Ниже представлена таблица, помогающая запомнить описание целочисленных, с которыми работает C. Double и float в соответствующую категорию не относятся, но они тоже являются простыми:
Размер (sizes) в битахБеззнаковыеЗнаковые
8Unsigned char – символы от 0 до 255.Char, -128 до 127
16Unsigned short, от 0 до 65 535Short, от -32 768 до 32 767
32 (или 4 байта)Unsigned int Int – обычное целое число. Максимальное значение – 32 767, минимальное – -32 767.
64Unsigned long intLong int
У каждого вида информации, не только целого, есть свой минимальный размер. Меньше соответствующего значения система не сможет выделить памяти на устройстве для нормальной работы элемента.
Вещественные
Сюда относят «числа с точкой». Это множество, которое включает в себя тип float в C (числа с плавающей запятой). К этой же категории относится double.
Вещественный тип (double и другие) используется для того, чтобы представлять в информатике действительные числа. Они представляются в разрядной сетке устройства в нормированной форме.
Нормированная форма числа с плавающей точкой – это наличие одной значащей цифры, отличной от нуля, до разделения целой и дробной части. Соответствующее представление умножается на основание системы счисления в соответствующей степени. Ниже – пример десятичных дробей:
В нормированной форме оно выглядит как:
В двоичной системе счисления значащий разряд, стоящий перед точкой (разделителем дробной и целой части) может быть равен только 1. Если число нельзя представить в нормированной форме, значащий размер перед разделителем целого и дроби будет равен нулю.
В C оператор может работать с тремя вещественными видами информации (включая double). Сюда относят:
Других вещественных вариаций язык программирования не предусматривает.
Логический
Логический тип добавлен в C99. Представлен ключевым словом _Bool. В отличие от double, может принимать всего два значения: истина и ложь.
Дополнительный заголовочный файл stdbool.h определяет для такого компонента псевдоним bool, а также макросы true и false. Ведет себя этот компонент точно так же, как встроенный тип (включая doubles), за исключением того, что любое ненулевое присваивание будет храниться в качестве единицы.
Здесь можно увидеть несколько наглядных примеров применения double и других типов информации в изученном языке.
P. S. Интересует разработка? Обратите внимание на курс «Программист C». Также в Otus доступно множество других современных курсов.
Типизация в информатике
Система типов – это совокупность правил в языках разработки, которые назначают свойства (они называются типами) разнообразных конструкциям, которые формируют исходный проект. К ним можно отнести:
Ключевая роль типизации – уменьшение количества ошибок в исходном коде за счет грамотного определения интерфейсов между разнообразными частями приложения и проверки согласованности взаимодействия «фрагментов» между собой. «Тестирование» может быть организовано статически (во время компиляции) или динамически (до формирования проекта в программу). Допускается сочетание соответствующих концепций.
Виды данных
Тип данных будет определять множество значений, набор операций, применяемых к соответствующим материалам, а также способ реализации хранения значений и выполнения операций. За счет этого «компонента» система сможет выделить тот или иной размер памяти на устройстве для нормального функционирования объекта кода.
Проверка и накладывание ограничений на виды используемых данных – это контроль типов или типизация. В языке C поддерживается ее статический вид. Это значит, что разработчик перед компиляцией должен самостоятельно определить виды используемой информации в задействованном проекте.
Рассматривая описание видов информации в IT и программировании, по умолчанию можно выделить следующие «классы»:
Первая категория – это самый распространенный вариант. Он включает в себя целочисленные типы, типы с плавающей запятой (вещественные), символьные и логические. Соответствующий вариант будет рассмотрен более подробно далее. Он используется как в простых, так и в достаточно сложных проектах чаще всего.
К составным вариантам относят:
Описание иных видов информации обычно ограничивается определением указателя и идентификатора.
Указатель – это компонент, который хранит адрес в памяти компьютера, указывающий на те или иные данные. Обычно работает с различными переменными.
Идентификатор – последовательность, размер которой составляет до 32 символов (латинский алфавит, подчеркивания, цифры). Является уникальным «именем» компонента в исходном программном коде.
Переменные разных типов имеют разные особенности и позволяют хранить числа в разных диапазонах.
boolean bool 1 байт * 0 или 1, true или false Логический тип
double – 4/8 байт -1.7E+308.. 1.7E+308 Для AVR то же самое, что float. На ESP и прочих 32-бит МК – 8 байт, точность – 15-16 знаков
– uint64_t 8 байт *** 2^64-1 Целые числа
Переменные целочисленных типов нужны для хранения целых чисел. В своей программе рекомендуется использовать альтернативное название типов (второй столбец в таблице выше), потому что:
Максимальные значения хранятся в константах, которые можно использовать в коде. Иногда это помогает избавиться от лишних вычислений:
Логический тип
bool – логический, он же булевый (придуман Джорджем Булем) тип данных, принимает значения 0 и 1 или false и true – ложь и правда. Используется для хранения состояний, например включено/выключено, а также для работы в условных конструкциях.
Также переменная типа bool принимает значение true, если присвоить ей любое отличное от нуля число.
bool a = 0; // false bool b = 1; // true bool c = 25; // true
Символьный тип
char – тип данных для хранения символов, символ указывается в одинарных кавычках: char var = ‘a’;. По факту это целочисленный тип данных, а переменная хранит номер (код) символа в таблице ASCII:
Отдельный символьный тип данных нужен для удобства работы, чтобы программа могла понять разницу между числом и символом, например для вывода на дисплей (чтобы вывести именно букву A, а не число 65). Из символов можно составлять строки, об этом более подробно поговорим в уроках про символьные строки и String-строки.
Символы и числа
Несмотря на то, что в языке Си символ это по сути целое число, значения например ‘3’ и 3 не равны между собой, потому что символ ‘3’ с точки зрения программы является числом 51. На практике иногда бывает нужно конвертировать символы чисел в соответствующие им целые числа и наоборот (при работе со строками и буферами вручную), для этого распространены следующие алгоритмы:
Дробные числа
float (англ. float – плавающий) – тип данных для чисел с плавающей точкой, т.е. десятичных дробей. Arduino поддерживает три типа ввода чисел с плавающей точкой:
Тип записи Пример Чему равно
Научный 2.34E5 2.34*10^5 или 234000
Инженерный 67e-12 67*10^-12 или 0.000000000067
float v; v = 123456.654321; // 123456.656250 v = 0.0123456789; // 0.0123456788 v = 0.0000123456789; // 0.0000123456788 v = 123456789; // 123456792.0
Другие особенности float чисел и работу с ними мы рассмотрим в уроках про математические операции и условия.
Константы
Что такое константа понятно из её названия – что-то, значение чего мы можем только прочитать и не можем изменить: при попытке изменить получим ошибку компиляции. Задать константу можно двумя способами:
Как переменную, указав перед типом данных слово const: const тип_данных имя = значение;. Пример: const byte myConst = 10;. По сути это будет обычная переменная, но её значение нельзя поменять. Особенности:
При помощи директивы #define, без знака равенства и точки с запятой в конце: #define имя значение. Пример: #define BTN_PIN 10. Работает так: указанное имя буквально заменяется в тексте программы на указанное значение. Такая дефайн-константа:
Во избежание проблем нужно называть дефайн-константы максимально уникальными именами. Можно добавлять к ним префиксы, например вместо PERIOD сделать MY_PERIOD и так далее.
Ключевые определения
Перед более детальным изучением data type необходимо в первую очередь выучить несколько понятий. Они пригодятся каждому, кто планирует разрабатывать программное обеспечение. Типизация в соответствующем деле – это «база», без которой создавать сложные проекты не представляется возможным.
Каждый программист должен знать следующие определения:
Когда разработчик поймет, что значит каждый приведенный выше термин, он может приступить к более детальному изучению типов информации в программировании. Особое внимание рекомендуется уделить типу double в C. Он используется так же часто, как и int.
Измерение информации
Максимальное количество значений, которое можно записать в один байт, составляет 2^8 = 256. В программировании счёт всегда начинается с нуля, поэтому один байт может хранить число от 0 до 255. Более подробно о двоичном представлении информации и битовых операциях мы поговорим в отдельном уроке.
Стандартные типы переменных в Arduino по своему размеру кратны степени двойки, давайте их распишем:
Заключение
В последнее время появляется много новых языков, смежных с C++, и я бы хотел увидеть на этих языках ряд экспериментов в такой фундаментальной области, как работа с целочисленными типами.
Симметричные знаковые целые числа упрощают работу со многими фундаментальными API, а 63-битный беззнаковый size_t может сочетать лучшее из знакового и беззнакового при работе с контейнерами. Конечно, нам пока не обойтись без настоящих беззнаковых типоа в ситуациях, когда требуется дополнительный бит. Но, поскольку он удваивает диапазон, я думаю, что было бы неплохо отказаться от настоящего INT_MIN, кроме как для взаимодействия с C. Различные битовые векторы могут повысить выразительность кода, но требуемые при этом преобразования также могут доставить немало головной боли. Я бы все же хотел, чтобы кто-нибудь попробовал такие эксперименты.