зачем нужен тип переменной
Что такое типы данных и зачем они нужны?
Пожалуйста, приостановите работу AdBlock на этом сайте.
Предполагается, что Вы всё ещё помните с прошлого шага, что такое переменная. Если не помните, вернитесь и посмотрите. А мы продолжаем.
Наверное, вам известно, что в памяти компьютера все числа хранятся в виде последовательности 0 и 1. Так вот, для того чтобы записать любое число только ноликами и единичками существуют определённые правила. Эти правила довольно сильно отличаются для целых чисел и для вещественных чисел. В памяти компьютера числа «3» и «3.0» будут записаны совершенно по-разному. Для тех, кто заинтересовался представлением чисел в памяти компьютера, в конце урока я дам ссылки на дополнительные материалы по этой теме.
Кроме того, зачастую компьютеры гораздо быстрее и лучше могут производить различные действия с целыми числами, чем с вещественными. Если вы не забросите этот курс, то на одном из следующих уроков мы в этом убедимся. Раньше, когда компьютеры занимали целую комнату, это была безусловная истина, а теперь этот факт уже нужно проверять.
Подведём итог. Каждая переменная должна иметь конкретный тип данных. И в эту переменную можно сохранить данные только этого типа.
Базовые типы данных в языке Си.
Ниже выписаны некоторые (не все!) базовые типы данных, которые есть в языке Си, и которые вы будете использовать в ваших программах чаще всего.
Для вещественных чисел есть ещё тип float. Он в некотором смысле хуже типа double. Две основные причины: у типа float меньше диапазон хранимых чисел, меньше точность (примерно 7 знаков после запятой, против 15 у типа double). Про точность у нас ещё будет пример в третьем уроке.
Есть и другие типы данных, но мы пока о них говорить не будем, чтобы не забивать свою память различными нюансами, которые на начальном этапе не так уж важны.
Важно другое. Необходимо понимать, что тип данных для переменной нужно выбирать в зависимости от того, что мы собираемся в этой переменной хранить. Например, если бы мы считали количество посещений какой-то страницы на сайте, то для этого мы использовали переменную типа int, а вот для хранения курса доллара целые числа уже бы не подошли. Думаю, у банка возникли бы серьёзные проблемы после использования такой программы.
Практика
Решите предложенные задачи. Для удобства работы сразу переходите в полноэкранный режим 
Исследовательские задачи для хакеров:
Немного о типах данных
Часто при обучении программированию возникают недопонимания типа: зачем в языке программирования нужно описывать типы данных, для чего это придумано и где у всего этого смысл.
Прежде чем рассмотреть, зачем нужен тип данных, сначала о том, что такое переменная. Вы присваиваете некоторому участку памяти, где может храниться информация имя – это имя и есть переменная. То есть, если ещё проще, то переменная – это имя некоторой записи в памяти компьютера. Хороший пример – сотовый телефон. Там, вы записи тоже часто храните под некоторыми именами. Например, под именем “магазин” вы можете хранить номер телефона магазина хоз. товаров. Имя “магазин” – переменная, а номер телефона – данные, что в ней хранятся. Вы можете отредактировать запись “магазин” сменив там номер телефона на другой, например, на номер телефона зоомагазина. И вот в той же самой переменной с тем же самым именем теперь уже лежит другая информация – раньше под именем “магазин” скрывался номер телефона хоз. товаров, а теперь там номер телефона зоомагазина. Итак, переменная – это имя, которое вы назначаете некоторому участку памяти, где может храниться разная информация.
Теперь о типе данных. Прежде чем присвоить какому-либо участку памяти имя, компьютеру необходимо «объяснить», данные какого типа будут храниться под эти именем. То есть когда создаёте переменную, то вы не только должны назначить ей некое имя, но также должны указать какого типа данные могут храниться под данным именем. Например, в языке c++ если вы создаёте переменную с именем shop таким образом:
int shop;
то это означает, что в участок памяти с именем shop вы можете записывать только целые числа (идентификатор типа int на это и указывает). Если потом запишете в программе:
то это будет означать, что в участке памяти под именем shop теперь хранится число 4. А вот если вы запишете:
Зачем нужен тип переменной
Давайте теперь разберемся с переменными, а именно что они из себя представляют и для чего служат. Разбираться мы будем на практике: для этого мы напишем вторую программу, которая будет запрашивать у пользователя поочередно два целых числа, затем складывать их и результат выводить на экран. Затем уже на этом примере разберемся с сущностью переменных в программировании. Хотя, я думаю, что вы все и сами поймете, изучив пример, в котором используются переменные.
Этот же текст с использованием однострочного комментария выглядел бы так:
Вот мы и разобрались с комментариями. Запомните и используйте в своих программах для ясности!
Прежде, чем использовать какую-либо переменную в программе, ее нужно объявить.
Объявить переменную можно в любом месте программы, до ее первого использования. Хотя желательно в своих программах придерживаться какого-либо одного стиля: например, объявлять в начале функции main(), как в этой программе.
Переменные могут хранить не только числовые значения, но и символьные, логические. Пока что мы рассматриваем только числовые. В данном случае мы объявили три переменные целого типа.
Можно также объявить эти переменные и в одну строку, т.к. их типы совпадают. Получится так:
Сейчас хочу немного сказать о синтаксисе языка. Как и в любом языке, понятном человеку, в компьютерном языке программирования тоже есть свой синтаксис. С его помощью определяют правила построения инструкций компьютеру. Рассмотрим синтаксис объявления переменных.
Следующая строка кода выводит значение этой переменной на экран:
Теперь начинаем кодить. Набирайте программу в среде CodeBlocks, компилируйте, запускайте на выполнение и экспериментируйте с ней. Вот теперь хоть какая-то, а польза уже есть с нашей программы, она складывает два числа как-никак)))
Для закрепления материала на операторы ввода/вывода и работу с переменными давайте наберем еще одну программу. Предлагаю разобраться с ней вам самим. Нового в ней будет то, что операции сложения, вычитания, деления и умножения можно производить непосредственно в потоке вывода, т.е. не нужно будет объявлять еще дополнительно переменную для хранения результата произведенных операций. Это еще одно удобство языка С++.
Не забывайте делать отступы для лучшей читабельности и ясности кода. Это очень важное замечание!
Напишите программу, которая запрашивает у пользователя три числа, записывает их в ранее объявленные переменные, а затем с помощью первого оператора вывода выводит их сумму, а во втором операторе вывода выводит их произведение. Сравните ваш код с кодом на следующей странице.
Вы также можете сами себе выдумать подобное задание и реализовать. Больше работайте в редакторе с программой, экспериментируйте с кодом и у вас все получится!
Типизация языков программирования: разбираемся в основах
Авторизуйтесь
Типизация языков программирования: разбираемся в основах
Типизация языков программирования — это то, как различные языки распознают типы переменных. Она определяет, как вы будете работать с типами переменных: нужно ли их задавать изначально, можно ли изменять и так далее.
Виды типизации
Языки программирования бывают типизированными и нетипизированными (бестиповыми).
Бестиповая типизация в основном присуща старым и низкоуровневым языкам программирования, например Forth. Все данные в таких языках считаются цепочками бит произвольной длины и, как следует из названия, не делятся на типы. Работа с ними труднее, и при чтении кода не всегда ясно, о каком типе переменной идет речь. Это можно исправить, написав комментарии к коду.
При этом у нетипизированных языков немало плюсов. В них можно совершать операции с любыми данными, и код получается более эффективным.
Перейдём к типизированным языкам.
Статическая и динамическая типизация
Особенность языков программирования со статической типизацией в том, что проверка типов начинается на стадии компиляции. Компиляторы ищут ошибки ещё до запуска программы, и вам не нужно раз за разом запускать её, чтобы выяснить, что пошло не так. Благодаря этому статически типизированные языки программирования зачастую быстрее. Кроме того, тип для переменной можно назначить только один раз. Например в Java такая запись вызовет ошибку на этапе компиляции:
В свою очередь, языки с динамической типизацией ищут ошибки на стадии исполнения. В них можно задать разные типы для одной и той же переменной, и они более гибкие. Например, в Python возможна такая запись, и ошибки не будет:
Сильная и слабая типизация
В слабо типизированных языках программирования можно смешивать разные типы данных. Так код получается короче — язык «старается» сам выполнять операции преобразования с разными типами. Впрочем, в таком случае не всегда ясно, как поведёт себя программа. Например, в JavaScript возможна такая запись:
При сильной или строгой типизации, как в Python, язык не позволяет смешивать разные типы — то есть, если вы обозначили переменную как число, то добавить к ней строку уже не получится:
Языки с сильной типизацией надёжнее. Да и программист, прописывая все преобразования вручную, лучше понимает, как работает его код.
Явная и неявная типизация
В языках программирования с явной типизацией типы переменных и возвращаемых значений функций нужно задавать. Это дольше, но так проще определять, что значат все данные, а программисту не придётся запоминать или записывать отдельно каждое значение. В языке С переменную нужно записывать так:
При неявной типизации тип переменной определяется интерпретатором или компилятором, поэтому записи в таких языках короче. Иногда они позволяют вручную указывать типы значений, как в Haskell или Python. В Python возможна такая запись, ведь язык сам определит, что это целое число:
Типизация в разных языках программирования
Разные категории могут пересекаться. Обычно языку программирования присуще одно значение из каждой группы: он может быть сильным или слабым, явным или неявным. Но есть несколько исключений. Так, Python с аннотациями может поддерживать явную типизацию, а язык D, наоборот, — неявную. С# поддерживает динамическую типизацию благодаря ключевым словам dynamic и var, Delphi — благодаря типу Variant, а С++ — с помощью библиотеки Boost и имеет одновременно черты языка с сильной и
слабой типизацией.
Типы данных, переменные
Начнём с типов памяти микроконтроллера, их целых три:
В ближайшее время нас будет интересовать только SRAM память, в которой хранятся переменные, именно о них дальше и пойдёт речь.
Двоичная система
В цифровом мире, к которому относится также микроконтроллер, информация хранится, преобразуется и передается в цифровом виде, то есть в виде нулей и единиц. Соответственно элементарная ячейка памяти, которая может запомнить 0 или 1, называется бит (bit). Таким образом мы плавно переходим к двоичной системе исчисления. Ну же, вспоминайте школьную информатику! Не вдаваясь в подробности “как это работает”, просто попробуем рассмотреть закономерность
| Двоичная | Десятичная |
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| … | … |
| 10000 | 16 |
И так далее. Помимо закономерности увеличения разрядов и чисел есть ещё одна: приглядитесь к числам в двоичной системе со всеми нулями справа от единицы:
| 10 | 2 |
| 100 | 4 |
| 1000 | 8 |
| 10000 | 16 |
Именно, степень двойки! Именно на степенях двойки в цифровом мире завязано очень много. Чтобы получить количество десятичных чисел, которые могут быть закодированы заданным количеством бит, нужно возвести 2 в степень количества бит. Смотрим на таблицу выше и продолжаем:
И так далее. Сразу нужно запомнить, что в программировании счёт начинается с нуля, то есть 5ю битами мы можем закодировать десятичное число от 0 до 31, 8-ю битами – от 0 до 255, 10-ю битами – от 0 до 1023. Очень важно понять и запомнить это, дальше очень пригодится. Следующая по величине единица измерения в цифровом мире – байт (byte), состоит из 8 бит. Почему 8? Исторически сложилось, что шины первых микропроцессоров имели разрядность 8 бит, возможно поэтому это количество приняли за более старшую единицу памяти. Также 8 это 2 в степени 3, что очень символично и удобно. А ещё, для кодирования всех латинских букв, знаков препинания, математических знаков и просто символов (всех что на клавиатуре) раньше хватало 7-ми бит (128 символов), но потом их стало мало, и ввели дополнительный бит, восьмой. То есть 8 бит это также размер таблицы символов, которая называется ASCII. К ней мы вернёмся уже в этой главе. Так что вопрос почему в одном байте 8 бит четкого ответа не имеет, ведь бывает и 6-ти битный байт, и 9-ти битный… Но это исключения старых процессоров, в современных цифровых устройствах в одном байте обычно содержится 8 бит (на отличных от AVR архитектурах может быть иначе), что позволяет закодировать 256 десятичных чисел от 0 до 255 соответственно. Дальше вы уже точно знаете:
Двоичная система является родной для микроконтроллера, и для работы с отдельными битами существует целый ряд инструментов, о них мы поговорим в уроке о битовых операциях из раздела продвинутых уроков.
Другие системы исчисления
Данные в памяти микроконтроллера хранятся в двоичном представлении, но помимо него существуют и другие системы исчисления, в которых мы можем работать. Постарайтесь сразу запомнить и понять, что переводить числа из одной системы исчисления в другую не нужно, Ардуино абсолютно всё равно, в каком формате вы скармливаете значение переменной, они автоматически будут интерпретированы в двоичный вид. Разные системы исчисления введены в первую очередь для удобства программиста. Теперь по сути: ардуино поддерживает (да в целом другого и не нужно) четыре классических системы исчисления: двоичную, восьмеричную, десятичную и шестнадцатеричную. Да, и до неё добрались. Краткая напоминалка: 16-ричная система имеет 16 значений на один разряд, первые 10 как у десятичной, остальные – первые буквы латинского алфавита: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f. С десятичной системой всё просто, пишем числа так, как они выглядят. 10 это десять, 25 это двадцать пять, и так далее. Двоичная (Binary) имеет префикс 0b (ноль бэ) или B, то есть двоичное число 101 запишется как 0b101 ИЛИ B101. Восьмеричная (Octal) имеет префикс 0 (ноль), например 012. Шестнадцатеричная (hexadecimal) имеет префикс 0x (ноль икс), FF19 запишется как 0xFF19.
| Базис | Префикс | Пример | Особенности |
| 2 (двоичная) | B или 0b (ноль бэ) | B1101001 | цифры 0 и 1 |
| 8 (восьмеричная) | 0 (ноль) | 0175 | цифры 0 – 7 |
| 10 (десятичная) | нет | 100500 | цифры 0 – 9 |
| 16 (шестнадцатеричная) | 0x (ноль икс) | 0xFF21A | цифры 0-9, буквы A-F |
Основная фишка 16-ричной системы в том, что она позволяет записывать длинные десятиричные числа короче, например один байт (255) запишется как 0xFF, два байта (65 535) как 0xFFFF, а жуткие три байта (16 777 215) как 0xFFFFFF. Вы не представляете (или уже имеете представление), насколько удобно и понятно это позволяет работать с цветами и оттенками. Двоичная же система обычно используется для наглядного представления данных и низкоуровневых конфигураций различного железа. Например конфиг кодируется одним байтом, каждый бит в нём отвечает за отдельную настройку (вкл/выкл), и передав один байт вида 0b10110100 можно сразу кучу всего настроить, к этому мы вернёмся в уроке работа с регистрами из раздела продвинутых уроков. В документации по этому поводу пишут в стиле “первый бит отвечает за это, второй за то” и так далее.
Переменные
Переменная – это ячейка SRAM памяти, которая имеет своё уникальное название и хранит числа соответственно своему размеру. К переменной мы можем обратиться по её имени и получить значение, либо изменить его. Степень двойки преследует нас и дальше, ведь объём одной ячейки памяти в микроконтроллере тоже ей кратен:
Да, больше четырёх байт в ардуино (точнее в МК от AVR) уже не влезет, при использовании обычных типов данных. Для работы с разными диапазонами значений используются разные типы данных (переменных). По сути можно использовать 4 байта для хранения чего угодно, но это не оптимально. Это как знать, что вам нужно будет унести максимум 200 мл воды (меньше 1 байта), но вы всё равно берёте 19 литровую бутыль (2 байта). Или железнодорожную цистерну на 120 тонн (4 байта). Если хотите писать красивый и оптимальный код, используйте соответствующие типы данных. Кстати, вот они:
Типы данных
*Не встречал упоминания об этом в официальных источниках, но Ардуино (точнее компилятор) также поддерживает 64 битные числа, соответственно тип данных int64_t и uint64_t Максимальный размер всех типов данных хранится в константах, и его можно использовать в коде по надобности:
Есть ещё несколько нестандартных типов, которые иногда встречаются в чужом коде:
Объявление и инициализация переменных
Преобразование типов
Преобразование _cast (Pro)
Иногда можно встретить преобразование типов через оператор cast. Отличную статью можно глянуть на Хабре, а я кратко опишу 4 основных каста:
Как пользоваться: на примере предыдущего примера
Константы
Что такое константа понятно из её названия – что-то, значение чего мы можем только прочитать и не можем изменить. Задать (объявить) константу можно двумя способами:
Ещё пару слов о константах и переменных: если обычная переменная нигде не изменяется в процессе выполнения программы – компилятор может самостоятельно сделать её константой и она не займёт места в оперативной памяти, т.е. будет помещена во Flash.
Область видимости
Переменные, константы и другие типы данных (структуры и перечисления) имеют такое важное понятие, как область видимости. Она бывает
Глобальная
Глобальная переменная объявляется вне функций и доступна для чтения и записи в любом месте программы, в любой её функции.
Локальная
Локальная переменная живёт внутри функции или внутри любого блока кода, заключённого в < фигурные скобки >, доступна для чтения и записи только внутри него. При попытке обратиться к локальной переменной из другой функции (за пределами её < блока >) вы получите ошибку, потому что локальная переменная создаётся заново при выполнении содержащего её блока кода (или функции) и удаляется из памяти при завершении выполнения этого блока (или функции):
Важный момент: если имя локальной переменной совпадает с глобальной, то приоритет обращения по имени в функции отдаётся локальной переменной:
Формальная (параметр)
Формальная переменная, она же параметр, передаваемый в функцию, ведёт себя как обыкновенная локальная переменная, но появляется при немного других условиях: при вызове функции. Эту переменную можно читать и менять внутри её функции. Также читайте отдельный урок про функции.
Структуры (Pro)
Структура struct – очень интересный тип данных: это совокупность разнотипных переменных, объединённых одним именем. В некоторых случаях структуры позволяют очень сильно упростить написание кода, сделать его более логичным и легко модифицируемым. Тип данных структура объявляется вот по такой схеме:
Ярлык будет являться новым типом данных, и, используя этот ярлык, можно объявлять уже непосредственно саму структуру:
Также есть вариант объявления структуры без создания ярлыка, т.е. создаём структуру, не объявляя её как тип данных со своим именем.
Рассмотрим большой пример, где показано всё вышеописанное
Размер элемента структуры
Структуры позволяют делать одну очень интересную вещь для оптимизации памяти: указывать максимальный вес элемента в битах. Таким образом можно делать даже однобитные флаги (обычный bool / boolean занимает в памяти 8 бит). Делается это при помощи оператора двоеточие :
Вложенные структуры
Структуры также могут быть вложенными друг в друга, доступ к нужному элементу осуществляется так же при помощи оператора “точка”, смотрите простой пример:
Перечисления (Pro)
Перечисления ( enum – enumeration) – тип данных, представляющий собой набор именованных констант, нужен в первую очередь для удобства программиста. Сразу пример из опыта: допустим у нас есть переменная mode, отвечающая за номер режима работы устройства. Мы для себя запоминаем, какому значению переменной какой режим будет соответствовать, и где-нибудь себе записываем, например 0 – обычный режим, 1 – режим ожидания, 2 – режим настройки_1, 3 – режим настройки_2, 4 – калибровка, 5 – аварийный режим, ошибка. При написании или чтении программы часто придётся обращаться к этому списку, чтобы не запутаться. Можно сделать первый шаг по оптимизации: обозвать каждый режим при помощи дефайна:
Таким образом вместо цифры можно будет использовать понятные слова и ориентироваться в коде будет гораздо проще. Использование enum ещё немного упрощает эту конструкцию: перечисление позволяет создать переменную (по умолчанию типа int ), которая может принимать только те “названия”, которые для неё указаны. Это удобно тем, что в одной программе могут находиться разные хранители режимов с одинаковыми названиями, и в отличие от #define это не будет приводить к ошибкам. Объявление перечисления чем-то похоже на объявление структуры:
Таким образом мы объявили ярлык. Теперь, используя этот ярлык, можно объявить само перечисление:
Также как и у структур, можно объявить перечисление без создания ярлыка (зачем нам лишняя строчка?):
Созданное таким образом перечисление является переменной, которая может принимать указанные для неё имена, также с этими именами её можно сравнивать. Теперь самое главное: имена для программы являются числами, начиная с 0 и далее по порядку увеличиваясь на 1. В абстрактном примере выше имя1 равно 0, имя2 равно 1, имя3 равно 2, и так далее. Помимо указанных имён, перечислению можно приравнять и число напрямую, но как бы зачем. Рассмотрим пример!
Таким образом SET1 имеет значение 1, SET2 будет 2 и так далее по порядку.
Пользовательские типы (Pro)
В С++ (и на Ардуино) этого делать не нужно! Наоборот, typedef в этом применении может приводить к ошибкам. Например:
Пространство имён (Pro)
Пространство имён – очень удобная возможность языка, с её помощью можно разделить функции или переменные с одинаковыми именами друг от друга, то есть защитить свой набор данных инструментов от конфликтов имён с другими именами. “Именная область” определяется при помощи оператора namespace :
Чтобы использовать содержимое из пространства имён, нужно обратиться через его название и оператор разрешения области видимости ::
Более подробный пример:
И ниже по коду можно будет пользоваться содержимым пространства имён без обращения через имя::
Спецификаторы (Pro)
Помимо возможности сделать переменную константой при помощи спецификатора const у нас есть ещё несколько интересных инструментов по работе с переменной.
static
static – делает переменную (или константу) статичной. Что это значит? Статичная локальная Для начала вспомним, как работает обычная локальная переменная: при вызове функции локальная переменная создаётся заново и получает нулевое значение, если не указано иначе. Если локальная переменная объявлена как static – она будет хранить своё значение от вызова к вызову функции, то есть станет грубо говоря глобально-локальной. Пример:
Статическая локальная:
extern
extern – указывает компилятору, что переменная объявлена где-то в другом файле программы, и при компиляции он её найдёт и будет использовать. А если не найдёт – ошибки не будет. Например при помощи данного кода можно сбросить счётчик millis()
volatile
volatile – данный спецификатор указывает компилятору, что данную переменную не нужно оптимизировать и её значение может быть изменено откуда-то извне. Обычно переменные с таким спецификатором используются в обработчиках прерываний. Вычисления с такими переменными также не оптимизируются и занимают больше процессорного времени.