Языки программирования что такое переменная. Переменная в программировании это простым языком

Что такое переменная?

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

Переменная – это именованная область памяти.

Но что это означает для нас. Давайте разбираться на примере.

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

Представь себе коробочку. На этой коробочке написано «Подарок» и это делает эту коробочку уникальной. Ты всегда сможешь найти именно эту коробку по этому имени (при условии, что не может существовать ни одной другой коробочки с таким именем).

А вот положить в эту коробочку ты можешь все что угодно. Это может быть и новенький IPhone, и миленький котеночек, и что-нибудь куда менее приятное (как в фильме «Семь»). Кстати, если не смотрел этот фильм, очень рекомендую, но только если у тебя крепкая психика и тебе больше 18 лет.

И в дальнейшем ты можешь как угодно работать с этой коробочкой. В любой момент ты можешь положить туда что-нибудь (предварительно выкинув оттуда то, что там лежало раньше), посмотреть, что там лежит, или вообще взять и выкинуть эту коробочку со всем содержимым.

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

Типизация переменных

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

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

Языки программирования условно можно разделить на два больших типа:

Сильнотипизированные – те, где вся ответственность за указание типа переменных ложится на программиста

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

Язык C# относится к первым. Возможно, это лишает его такой гибкости как тот же самый JavaScript (который относится ко вторым), но при этом дает большую защищенность от ошибок.

Виды переменных в языке C#

Перед тем, как мы приступим к знакомству с основными типами данных в языке C# необходимо узнать изучить еще один вопрос – виды переменных. На самом деле их всего два:

Ссылочные – хранятся в куче (сложные типы и классы)

Значимые – хранятся в стеке (базовые примитивные типы)

Мы не будем подробно останавливаться на этой теме, но общая идея следующая:

Условно в компьютере существует два вида памяти для работы приложения:

Стек (Stack) – быстрая память, но сильно ограниченная по размеру

Куча (Heap) – память, ограниченная только размером оперативки, но при этом значительно более медленная, чем стек.

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

Статическая и динамическая типизация переменных

Если тип переменной определяется на этапе компиляции, имеет место статическая типизация, а если на этапе выполнения программы — динамическая. В последнем случае иногда говорят, что переменная не имеет типа, хотя данные, содержащиеся в ней, безусловно, относятся к определённому типу данных, но выясняется это уже во время выполнения программы.

В большинстве случаев статическая типизация позволяет уменьшить затраты ресурсов при выполнении программы, поскольку для динамической типизации требуются затраты ресурсов на выяснение типов данных их приведение в выражениях с смешанными типами. Статическая типизация позволяет перекладывать проверку типов на этапе компиляции программы. Это также упрощает обнаружение ошибок ещё на этапе разработки, когда их исправление обходится менее дорого. Тем не менее во многих случаях необходимо применение динамической типизации. Например, необходимость поддержания совместимости при переходе на новый формат представления данных (например, старая часть проекта посылает процедуре дату символьной строкой, а новые объекты используют более современный числовой тип).

Статические и динамические переменные

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

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

Локальные и глобальные переменные. Области видимости

По зоне видимости различают локальные и глобальные переменные. Первые доступны только конкретной подпрограмме, вторые — всей программе. С распространением модульного и объектного программирования, появились ещё и общие переменные (доступные для определённых уровней иерархии подпрограмм). Область видимости иногда задаётся классом памяти. Ограничение видимости может производиться путём введения пространств имён.

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

Простые и сложные переменные

По наличию внутренней структуры, переменные могут быть простыми или сложными (составными).

Простые переменные не имеют внутренней структуры, доступной для адресации. Последняя оговорка важна потому, что для компилятора или процессора переменная может быть сколь угодно сложной, но конкретная система (язык) программирования скрывает от программиста её внутреннюю структуру, позволяя адресоваться только «в целом».

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

Следует подчеркнуть относительность такого деления: для разных программ одна и та же переменная может иметь разную структуру. Например, компилятор различает в переменной вещественного типа 4 поля: знаки мантиссы и порядка, плюс их значения, но для программиста, компилирующего свою программу, вещественная переменная — единая ячейка памяти, хранящая вещественное число.

Допустимые имена для переменных

Идентификаторы переменных могут содержать в себе:

• латинские буквы;
• цифры;
• знак нижнего подчёркивания.

При этом название не может начинаться с цифр. Примеры названий:

• age;
• name;
• _sum;
• first_name;
• a_5.

Все идентификаторы регистрозависимы. Это значит, что name и Name — разные переменные.

Рекомендуется давать именам простые названия на английском языке, чтобы код был понятен и вам, и другим людям. Например:

• price, а не stoimost;
• currentId, а не pupa;
• carsCount, а не lupa и так далее.

Если название должно состоять из нескольких слов, то рекомендуется использовать camelCase (с англ. «верблюжий регистр»): первое слово пишется со строчной буквы, а каждое последующее — с заглавной.

Типы переменных в языке C#

Начнем со знакомства с наиболее часто используемыми типами данных (большинство их них значимые):

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

Надеюсь, ты заметил, что для типов float и decimal при дробном числе добавляется специальная литера (F и M соответственно). Это связано с тем, что по умолчанию в C# дробные числа хранятся в типе double, а это необходимо для того, чтобы компилятор правильно воспринимал эти числа. Для целых значений это не обязательно.

Целочисленные

Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:

1. Byte – принимает значение от -128 до 127. Размер этой переменной – 1 байт памяти, что вполне логично исходя из названия.
2. Short – может принимать значения от -32768 до 32767. Размер такой переменной 2 байта.
3. Int – эта целочисленная переменная может принимать значения от -2147483648 до 2147483647. Ее размер составляет 4 байта.
4. Long – это самая большая с точки зрения размера переменная (8 байтов памяти). Она может принимать значения от -9223372036854775808 до 9223372036854775807.

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

Теперь нам нужно понять, какую именно переменную использовать. Здесь важно вспомнить, какое именно значение может принимать та или иная целочисленная переменная. Например, мы точно знаем, что количество апельсинов не будет выходить за пределы 127. В этом случае, можно смело объявлять byte.

Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.

Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.

Приведем несколько примеров:

int oranges;

byte oranges;

long oranges;

В языке Java, как и в любом другом переменные лучше называть выразительно. То есть так, чтобы можно было понять, что именно в ней лежит. Например, если мы просто назовем три переменные byte oranges, не будет понятно, что это за апельсины.

Если речь идет об апельсинах Васи, такую переменную можно было бы назвать int vasyaOranges (или orangesVasya). Заметили одну интересную особенность? Слово vasya мы почему-то написали с маленькой, а Oranges с большой. Такой прием называется CamelCase. Он применяется тогда, когда название переменной или функции состоит из двух и более слов. Применяется исключительно для удобства. Читать переменную vasyaOranges куда удобнее, чем vasyaoranges. А если в названии переменной еще больше слов, то без CamelCase придется туго.

Переменные с плавающей точкой

Вернемся к тем же действующим лицам. Итак, Вася, Катя и Аня снова держат апельсины. Только на этот раз, Васе досталось 3,5, Кате 2,5, а Ане 1,5 апельсина. Цель задачи остается той же – посчитать общее количество фруктов на руках у ребят.

В этом случае мы не можем использовать целочисленные переменные, так как речь идет о дробных числах. То есть мы не можем применять byte, short, int или long. Для этого существуют float и double. При этом:

1. Float принимает значения от -3.4Е + 38 до 3.4Е + 38. Размер такой переменной 4 байта.
2. Double принимает значения от -1.7Е+308 до 1.7Е + 308. Размер переменной 8 байт.

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

float oranges

Здесь мы объявляем переменную с плавающей точкой oranges, куда впоследствии можно будет положить численное значение количества апельсинов. Здесь действует то же правило написания названия переменных, содержащих более двух слов:

float vasyaOranges (или orangesVasya)

Символы

Для char в Java предусмотрена Unicode кодировка. Диапазон значений составляет от 0 до 65536. Размер составляет 2 байта. При этом, в отличие от предыдущих типов переменных, отрицательных значений у char нет. Важно понимать, что в этой переменной не хранится сам символ. Здесь содержится его кодировка из Unicode. Соответственно, мы можем проводить целочисленные операции с символами.

С объявлением переменной типа char все также просто, как и с предыдущими:

char a;

char b;

В первом случае мы объявили символьную переменную а, а во втором – b.

Описание переменных

var имена переменных : тип;… имена переменных : тип;

Например:

var a, b, c: real; i, n: integer; f: boolean;

Ввод и вывод

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

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

read(переменные);

или

readln(переменные);

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

read(a, b);

компьютер будет ожидать ввода двух значений, которые затем будут помещены в переменные a и b.

Операторы read и readln отличаются тем, что во втором случае после ввода данных будет переведена строка, т.е. последующие сообщения компьютера будут выводиться с новой строки.

Оператор вывода нужен, чтобы компьютер показал результаты работы программы или какие-либо вспомогательные сообщения. В программе на Pascal он записывается следующим образом:

write(выражения);

или

writeln(выражения);

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

write(a + b, c);

на экран будет выведена сумма переменных a и b, а также значение переменной c. Если нужно вывести на экран какое-либо текстовое сообщение, его нужно заключить в апострофы (одиночные кавычки):

write(‘Нет решения’);

Операторы write и writeln отличаются тем, что во втором случае после вывода данных будет переведена строка, т.е. последующие сообщения компьютера будут выводиться с новой строки.

Присваивание

Для того чтобы переменная получила или изменила свое значение, используется оператор присваивания. В Pascal он записывается следующим образом:

переменная := выражение;

Тип переменной должен совпадать с типом выражения либо быть «более широким» совместимым (т.е. вещественной переменной можно присвоить значение целого выражения; строковой переменной можно присвоить значение символьного выражения).

Компьютер сначала вычисляет значение выражения в правой части оператора присваивания, затем помещает его в переменную, указанную слева от символа присваивания «:=».

Например, при выполнении оператора

x := a + b;

переменная x получит значение суммы переменных a и b. При выполнении оператора

n := n + 1

значение переменной n увеличится на единицу.

Запомните! При присваивании переменной нового значения старое будет потеряно безвозвратно. Например, после выполнения операторов a := b;

b := a;

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

Простейшая программа

Рассмотрим, как составить простую программу, выполняющую какие-либо вычисления. Для этого нам нужно:

1. Проанализировав условие задачи, выделить исходные данные и результаты. Выбрать для них имена переменных (если они не заданы в условии). Определить тип данных.
2. Построить математическую модель задачи — описание в виде набора математических соотношений.
3. Разработать (или подобрать из известных) алгоритм решения задачи — последовательность действий, приводящую от исходных данных к результатам за конечное число шагов. (Не забудьте, что сначала компьютер должен получить значения исходных данных, а после нахождения результатов — вывести эти результаты на экран).
4. Если в процессе решения используются промежуточные данные, выбрать имена переменных и определить их тип.
5. Записать программу в соответствии с правилами синтаксиса языка программирования (в нашем случае — Pascal).

Рассмотрим простейший пример.

Задача

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

Решение

1) Определим исходные данные и результаты задачи. В данном случае они явно указаны в условии: исходная величина — радиус, результаты — длина окружности и площадь круга. Используем для них традиционные обозначения: R, L и S, соответственно. Все эти переменные могут принимать как целые, так и дробные числовые значения, поэтому следует использовать вещественный тип данных, например, Real.

2) Математически задача описывается известными формулами:

L = 2 ⋅ π ⋅ R [1]

и

S = π ⋅ R2 [2].

3) Алгоритм в данном случае предельно прост:

1. Ввести значение радиуса.
2. Вычислить длину окружности по формуле [1].
3. Вычислить площадь круга по формуле [2].
4. Вывести значения длины окружности и площади круга на экран.

4) При вычислениях нам (точнее, компьютеру) потребуется значение π. Вообще говоря, практически все реализации Pascal имеют встроенную константу PI, но мы объявим подобную константу самостоятельно.

5) Теперь запишем программу:

program circle; { Имя программы можно выбирать произвольно }{ В фигурных скобках записываем комментарии — этот текст компьютер пропускает } const p = 3.14159265358; { Объявление константы } var L, R, S: Real; { Все переменные одного тип }begin write (‘Введите величину радиуса:’); { Выводим на экран пояснение } readln (R); { Вводим значение и переходим на новую строку } L := 2 * p * R; { Операция умножения обязательно указывается! } S := p * R * R; { Можно записать S := p * sqr(R); } writeln (‘L=’, L:10:3, ‘ S=’, S:10:3); { Выводим поясняющий текст } { и значения переменных. Для значений указан } { формат: всего 10 знаков, из них 3 — после точки. }end.

Использование переменных

Можно различать разные способы использования переменных:

• Входные переменные получают значения, которые вводятся в программу , функцию или метод извне (см. Параметры ).
• Выходные переменные позже содержат результаты расчета.
• Ссылочные переменные ( указатели ) служат как входными, так и выходными переменными. Значение можно изменить в процессе расчета.
• Вспомогательные переменные записывают значения, которые требуются в процессе расчета.
• Переменные среды представляют собой внешние граничные условия программы .
• Метасинтаксические переменные используются просто для обозначения сущностей или частей программного кода .
• Переменные времени выполнения

Представления переменных

Понятие переменных интерпретируется по-разному в языках программирования :

• В чисто функциональном языке программирования переменные — это просто идентификаторы , то есть они используются, как в лямбда-исчислении , только для обозначения входных параметров функции . Следовательно, значение переменной не изменяется во время вычисления значения функции. Выражение с переменными всегда имеет то же значение, независимо от того, где это происходит в программе . Это свойство известно как ссылочная прозрачность .
• в императивном языке программирования , с другой стороны, значение переменной может изменяться в то время как программа работает. Таким образом, одно и то же выражение с переменными может иметь совершенно разные значения в разных точках программы или в разное время во время выполнения программы.

Соответственно, разные языки программирования по- разному определяют понятие переменных. В случае Java это говорит:

«Переменная — это ячейка памяти».

Однако в языковом определении Scheme говорится:

«Схема позволяет идентификаторам заменять места хранения, содержащие значения.
Такие идентификаторы называются переменными ».

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

• само пространство для хранения как контейнер для данных,
• данные, хранящиеся в ячейке памяти,
• адрес ячейки памяти и
• идентификатор , при котором пространство для хранения может быть решено.

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

L-значение и R-значение переменных

Для императивных языков программирования характерно, что идентификатор в левой части присвоения значения имеет другое значение («L-значение»), чем в его правой части («R-значение»). Инструкция

x := x + 1

означает: «Возьмите значение переменной с именем x, увеличить его на единицу и сохранить это в адрес в x.» Таким образом, L значение переменной является ее адрес, то значение r его содержание.

Переменные как параметры функций

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

Переменные в аппаратном обеспечении

Для программистов переменные удобны и интуитивно понятны. С другой стороны, для вычислительной техники они не имеют реального значения. Микропроцессоры хранят данные в регистрах и ячейках памяти. Это фундаментальное различие между людьми, которые пишут прошивку, и машинами, которые выполняют прошивку, преодолевается языками высокого уровня, такими как C, который обрабатывает различные детали, связанные с переводом между текстовыми переменными и физической реальностью процессора.

Разработчики встраиваемых систем часто работают с 8-разрядными процессорами. В этих устройствах основной размер данных всегда составляет один байт. Память организована в соответствии с байтами, размер регистров составляет один байт, а сам CPU предназначен для обработки 8-разрядных данных. Это довольно неудобное ограничение, поскольку во многих ситуациях значение переменной будет превышать максимальное значение 8-разрядного числа.

В итоге все ваши тщательно определенные, грамотно названные переменные на C заканчиваются битами в памяти (или в регистрах)

Язык C не ограничивает размер переменной до 8 бит, даже когда вы работаете с 8-разрядным процессором. Это означает, что одна переменная в вашей прошивке может соответствовать нескольким регистрам или ячейкам памяти в аппаратном обеспечении. «Ручное» управление многобайтовыми переменными (т.е. через язык ассемблера) не является моей забавой, но компиляторы не возражают против этого, и они выполняют свою работу очень хорошо.

Определение переменных

Первым шагом в использовании переменной является определение этой переменной. Основными компонентами определения переменной являются тип и имя.

Существует много типов переменных; полный список, а также подробности аппаратной реализации будут зависеть от того, какой компилятор вы используете. Вот некоторые типы:

• char: однобайтовое целое значение со знаком;
• int: двух- или четырехбайтовое целое значение со знаком;
• long: четырехбайтовое целое значение со знаком;
• float: четырехбайтовое значение, которое может иметь числа после десятичной запятой – другими словами, оно не ограничивается целыми числами;
• bit: значение переменной может быть ноль или единица.

Это наглядное представление о том, как последовательность битов интерпретируется по-разному, в зависимости от того, интерпретируется ли переменная как со знаком (с использованием двоичной записи) или без знака.

Следующий код показывает определения переменных, которые состоят только из базового типа и имени (более технический способ ссылка на имя – это «идентификатор»):

int ADC_result; char ReceivedByte; float Reference_Voltage;

Инициализация переменной

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

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

int ADC_result = 0; char ReceivedByte = 0x00; float Reference_Voltage = 2.4;

Настраиваемые определения переменных

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

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

• unsigned: Как вы могли догадаться, это говорит компилятору интерпретировать переменную как значение без знака, а не как значение со знаком. Я определяю большинство переменных как беззнаковые, потому что мне редко нужны отрицательные числа.
• const: Классификатор типа const указывает компилятору, что значение переменной не должно изменяться. Как я уже упоминал в начале статьи, иногда значение «переменной» в C не является переменной. Если вы допустите ошибку в своем коде и попытаетесь изменить значение переменной const, компилятор выдаст ошибку.
• volatile: Сложные компиляторы не просто берут исходный код и напрямую переводят его в собранную прошивку. Они также пытаются заставить код работать более эффективно, и этот процесс называется «оптимизацией». Однако время от времени это может испортить ваш день, потому что компилятор оптимизирует только на основе кода и не может учитывать аппаратные события, которые взаимодействуют с вашим кодом. Когда переменная имеет спецификатор типа volatile, компилятор знает, что он должен быть осторожен с оптимизациями, которые связаны с этой переменной.
  Прерывание может привести к изменению значения переменной так, как этого не ожидает компилятор, и это может привести к проблемной оптимизации
• типы памяти, такие как xdata, idata и code: Эти ключевые слова заставляют компилятор размещать переменную в определенной части памяти микропроцессора. Тип памяти code особенно удобен: ресурсы оперативной памяти RAM часто гораздо более ограничены, чем энергонезависимая память программы, а тип памяти code позволяет использовать дополнительную память программы для хранения данных, которые используются в вашей программе, но никогда не изменяются.

Вот некоторые примеры:

// переменная принимает значения в диапазоне от 0 до 255 unsigned char UART_byte; const float PI = 3.14159; // содержимое регистра может изменяться аппаратным обеспечением, // поэтому мы используем квалификатор volatile, чтобы избежать // оптимизаций, которые могли бы заставить программу игнорировать // события, генерируемые аппаратным обеспечением. volatile unsigned char ADC_Register; unsigned char code CalibrationValue = 78;

Использование своих переменных

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

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