Когда нужно объявлять переменные

0

Язык С: переменные

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

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

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

• char — целочисленный тип, представляющий обычно один октет (один восьмибитовый байт);
• int — наиболее естественный размер целого числа для компьютера;
• float — значение с плавающей запятой одинарной точности;
• double — значение с плавающей запятой двойной точности;
• void — представляет отсутствие типа.

Язык C также позволяет определять другие типы переменных (перечисление, указатель, массив, структура, объединение и т.д.), которые будут рассмотрены в последующих разделах. Здесь уделим внимание только основным типам переменных.

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

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

Здесь type должен быть допустимым типом данных языка C, включая char , w_char , int , float , double , bool или любой объект, определяемый пользователем; а variable_list может состоять из одного или нескольких имен идентификаторов, разделенных запятыми. Ниже показаны некоторые допустимые объявления:

Строка int i, j, k; объявляет и определяет переменные i , j и k ; которые инструктируют компилятор создать переменные с именами i , j и k типа int .

Переменные могут быть инициализированы (им присваивается начальное значение) в их объявлении. Блок инициализации состоит из знака равенства, за которым следует константное выражение, как показано ниже:

Определение без инициализации: переменные со статической длительностью хранения неявно инициализируются со значением NULL (все байты имеют значение 0 ); начальное значение всех остальных переменных не определено.

Объявление переменных

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

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

Пример

Рассмотрим пример, где переменные были объявлены в самом верху, но определены и инициализированы внутри главной функции.

Когда приведенный выше код компилируется и выполняется, выдается следующий результат:

Тот же принцип применим к объявлению функции, когда вы указываете имя функции во время ее объявления, а ее фактическое определение может быть дано в любом другом месте. Например:

L-значения и R-значения

В языке C есть два вида выражений:

1. L-значения. Выражения, которые ссылаются на область памяти, называются выражениями l-значения. L-значение может появляться как в левой, так и в правой части присваивания.
2. R-значения. Термин r-значение относится к значению данных, которое хранится по некоторому адресу в памяти. R-значение — это выражение, которому не может быть присвоено значение, что означает, что r-значение может появляться только в правой части присваивания.

Переменные — это l-значения, поэтому они могут появляться в левой части присваивания. Числовые литералы являются r-значениями, поэтому их нельзя присвоить и они не могут появляться в левой части. Посмотрите на следующие допустимые и недопустимые операторы:

Name already in use

StudentCpp-wiki / 1.1. Переменные.md

• Go to file T
• Go to line L
• Copy path
• Copy permalink

• Open with Desktop
• View raw
• Copy raw contents Copy raw contents

Copy raw contents

Copy raw contents

Переменная — это область память с заданным символьным именем.

В этой строчке в памяти выделяется память для хранения целочисленного числа и в программе к этой области памяти мы сможем обращаться по имени «а».

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

Объявление переменной — процесс резервирования в памяти нужного объема памяти и присвоения этой области памяти какого-то имени.

Резервирование памяти — явление, при котором программа помечает область памяти «занятой», чтобы не произошло непроизвольного изменения данных в этом участке памяти.

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

Для объявления переменной сначала пишут имя типа данных будущей переменной, а затем имя этой переменной.

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

Сначала может показаться, что имя типа данных определеяет только то, сколько памяти будет зарезервировано под переменную. Но это так. Переменные а2 и а3 будут занимать в памяти одно и то же количество байт, но если выполнить следующий код:

Маленькое замечение: в языке С++ логический тип данных ничем не отличается от числового. Все, что отлично от 0 — истина, и только сам 0 — ложь.

Итак, обратите внимание, что на деле переменные а2 и а3 обе в одном байте памяти хранят число 65. Но при выводе на экран, а2 выводится как символ, а а3 как число (более продвинутый язык С# бы вывел как и положено логическому типу данных фразу «true» — истина, но это С++, поэтому сильно не переживайте по этому поводу). Почему?

Все из-за разных типов данных этих переменных.

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

Объявление и инициализацию можно совмещать

ВАЖНО! Считается обязательным давать переменным вразумительные имена, чтобы только по самому имени переменной было понятно, для чего она создана Например, переменные счетчики называют

Чтобы посчитать что-то, то используют имя

Имеется в виду, что c — сокращение от character — символ. Вообще привыкайте, что знать английский язык нужно на уровне «читать»-«писать» как минимум

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

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

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

Инициализация переменной — процесс записи в область памяти какого-то значения.

Объявление переменной и инициализацию можно объядинать в одном выражении:

Локальные и глобальные переменные

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

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

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

Однако, согласитесь может возникнуть премерзкая ситуация:

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

У нас сейчас в одном алгоритме получилось, что объявлено 2 переменных с одним и тем же именем — b. Вроде бы, должна быть ошибка, потому что возникает неоднозначность, какая переменная b, где используется.

Логически мы понимаем, что в двух разных блоках кода — две разные переменные b. И это правильно. Чтобы избежать таких конфликтов в С++ тоже есть понятия, которые позволяют избежать таких неоднозначностей: локальная переменные и глобальные переменные.

Внутри ф-ции мы не объявляли переменную count. Но она все равно доступна, и мы увеличиваем ее значение

В начале программы обнуляем значение переменной. То же самое — внутри main не было объявления переменной, но доступ к ней мы имеем

Если кратко:

1. Глобальные переменные хранятся на протяжение выполнения всей программы. Т.е. занимают под себя место.
2. Имя глобальной переменной занято. Создание локальной переменной в таким же именем затруднит чтение кода.
3. Алгоритм программы становится менее прозрачным, потому что вам нужно знать про все глобальные переменные, какие есть в коде.

Если очень кратко: ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ — ПЛОХО! НЕ ИСПОЛЬЗУЙТЕ ИХ.

Если хотите более развернутого ответа, то можете погуглить. Например, http://www.gunsmoker.ru/2011/04/blog-post.html

Глобальные переменные доступны из любого места в модуле программы. (Т.к. с понятием модуля в языке С++ кто-то может быть пока что не знаком, считайте, что это тот файл, в котором вы пишете код, например, main.cpp)

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

Блок кода — код расположенный между символами ‘<' и '>‘

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

Дело в том, что в памяти программы глобальные переменные занимают свое особое пространство. И не всегда вы можете быть уверены, что это пространство безгранично. Но даже не это страшно в бездумном использовании глобальных переменных.

Самое плохое — это снижение читаемости и понятности кода. Когда вы используете глобальную переменную в программах сложнее «Hello, World!» вам становится сложно сказать, где и в какой момент меняется состояние этой переменной. Вы не контролируете уровни доступа до нее. Вы можете забыть, где меняется эта переменная, а потом долга искать, почему данные в памяти имеют такой странный вид. Все это сделало использование глобальных переменных нежелательным.

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

Глобальные переменные плохи по двум причинам:

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

Снижение читабельности кода программы

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

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

Переменная c объявлена в фун-ции Func, поэтому существует только в рамках этой функции. Внутри функции main ее не существует, поэтому при попытке любого к ней обращения будет выдаваться ошибка.

Переменная а объявлена в фун-ции main и существует как в самой функции main, так и во всех дочерних блоках кода любой вложенности. Поэтому переменная а видна в любом месте функции main, в том числе внутри цикла for.

Переменные b и i (!) объявлены внутри цикла for. И да, переменная i является локальной переменной цикла for! Обе этих пермеенные существуют только в рамках цикла и после его завершения уже не существуют.

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

Поэтому на протяжение цикла, переменная i будет выводиться на экран как 0, 1, 2, 3, . 9, а переменная b все время будет выводиться на экран равное 2.

Где хранятся локальные переменные

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

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

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

Типы данных в любом языке программирования делятся на 2 вида:

• базовые (встроенные) могут быть использованы «из коробки», они доступны стандартными средствами языка программирования
• пользовательские создаются самим программистом под какие-то свои индивидуальные задачи

Пользовательские типы данных будут рассмотрены в темах «Структуры» и «Классы». Сейчас рассмотрим перечень основных базовых типов данных:

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

Хранит всего 2 значения: истина ( true ) или ложь ( false ). Но естественно не смотря на это занимает в памяти полноценный байт памяти по правилу «наименьшая адресуемая ячейка памяти = 1 байту».

Причем в языке С++ истоной является все, что отлично от 0 (нуля), а ложью будет только значение равное нулю. Например,

• 10 — это true
• -1 — это true
• 1 — это true
• 0 — это false

Причем, в С++ работает даже такой код:

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

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

Переменная типа данных char будет хранить символ и занимать в памяти 1 байт памяти. Соответственно, char переменная изменяется в диапазоне от 0 до 255. Причем это число является кодом символа из таблицы ASCII (Полный перечень кодов таблицы ASCII).

Тип данных char дает программе понять, что при выводе такой переменной на экран нужно выводить не число, а символ с таким кодом.

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

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

• short занимает 2 байта
• int занимает 4 байта
• long занимает 8 байт

Как можно легко вычислить диапазон чисел, который может хранить целочисленный тип данных. Возьмем для примера short :

2 байта — 16 бит, т.е. 16 разрядов. Максимальное число, которое может храниться в двоичном представлении это:

или это число еще можно записать как:

А это число легко можно записать уже на «человеческом языке» как

2 в степени 16 (потому что единица стоит в 16-ом разряде) минус единица. Возьмите калькулятор и посчитайте (или если вы крутой, то посчитайте в уме), какое получается число.

Итак, это число 65535 . Таким образом диапазон типа данных short изменяет от 0 до 65535. Но на самом деле так изменяется unsigned short — беззнаковый вариант этого типа данных.

Сам же short изменяется в диапазоне от -32768 до 32767 — беззнаковый диапазон поделился по сути пополам.

Теперь вы можете легко высчитывать диапазон изменения целочисленных переменных в зависимости от типа данных.

Кстати, маленькое замечание: short , int , long — это всего лишь псевдонимы типов данных. И эти псевдонимы могут на разных платформах и архитектурах скрывать различные типы данных с разными размерами. На самом деле, при написании кросс-платформенных приложений лучше пользоваться системными названиями __int16 , __int32 , __int64 и т.д. Но когда это не жизненно важно, то обычно пользуются именами-псевдонимами.

Типы данных с плавающей запятой

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

Переменные — место хранения необходимой информации

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

Инструменты, которые вам нужны

В этой статье вам будет предложено ввести строки кода, чтобы проверить ваше понимание материала. Если вы используете браузер для настольных компьютеров, лучшим примером для ввода кода примера является консоль JavaScript вашего браузера (см. What are browser developer tools для получения дополнительной информации о том, как получить доступ к этому инструменту).

Также мы предоставили простую консоль JavaScript, встроенную ниже в странице, для ввода кода, если вы не используете браузер с консолью JavaScript или консоль на странице окажется для вас более комфортной.

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

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

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

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

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

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

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

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

Объявление переменной

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

Здесь мы создаём две переменные myName и myAge. Попробуйте ввести эти строки сейчас в консоли вашего веб-браузера или в консоли ниже (можно открыть эту консоль в отдельной вкладке или в новом окне). После этого попробуйте создать переменную (или две) с вашими именами.

Примечание: в JavaScript все инструкции кода должны заканчиваться точкой с запятой (;) — ваш код может работать правильно для отдельных строк, но, вероятно, не будет, когда вы пишете несколько строк кода вместе. Попытайтесь превратить написание точки с запятой в привычку.

Теперь проверим, существуют ли эти значения в среде выполнения. Для этого введём только имя переменной.

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

Примечание: Не путайте переменную, которая существует, но не имеет значения, с переменной, которая вообще не существует — это разные вещи.

Присвоение значения переменной

Как только переменная объявлена, ей можно присвоить значение. Для этого пишется имя переменной, затем следует знак равенства ( = ), а за ним значение, которое вы хотите присвоить. Например:

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

Вы можете объявить переменную и задать ей значение одновременно:

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

Примечание: Если вы пишете многострочную программу JavaScript, которая объявляет и инициализирует (задаёт значение) переменную, вы можете объявить её после её инициализации, и она всё равно будет работать. Это связано с тем, что объявления переменных обычно выполняются первыми, прежде чем остальная часть кода будет выполнена. Это называется hoisting — прочитайте var hoisting для более подробной информации по этому вопросу.

Обновление переменной

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

Правила именования переменных

Вы можете назвать переменную как угодно, но есть ограничения. Как правило, вы должны придерживаться только латинских символов (0-9, a-z, A-Z) и символа подчёркивания.

• Не рекомендуется использование других символов, потому что они могут вызывать ошибки или быть непонятными для международной аудитории.
• Не используйте символы подчёркивания в начале имён переменных — это используется в некоторых конструкциях JavaScript для обозначения конкретных вещей.
• Не используйте числа в начале переменных. Это недопустимо и приведёт к ошибке.
• Общепринято придерживаться так называемый «lower camel case», где вы склеиваете несколько слов, используя строчные буквы для всего первого слова, а затем заглавные буквы последующих слов. Мы использовали это для наших имён переменных в этой статье.
• Делайте имена переменных такими, чтобы было интуитивно понятно, какие данные они содержат. Не используйте только отдельные буквы / цифры или большие длинные фразы.
• Переменные чувствительны к регистру, так что myage и myAge — разные переменные.
• И последнее — вам также нужно избегать использования зарезервированных слов JavaScript в качестве имён переменных — под этим мы подразумеваем слова, которые составляют фактический синтаксис JavaScript! Таким образом, вы не можете использовать слова типа var , function , let , и for для имён переменных. Браузеры распознают их как разные элементы кода, и поэтому возникают ошибки.

Примечание: По ссылке можно найти довольно полный список зарезервированных ключевых слов: Lexical grammar — keywords.

Примеры хороших имён переменных:

Примеры плохих имён переменных:

Примеры имён переменных, которые вызовут ошибки:

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

Типы переменных

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

Числа (Numbers)

Вы можете хранить числа в переменных (целые числа, такие как 30, или десятичные числа, такие как 2.456, также называемые числами с плавающей точкой или с плавающей запятой). Вам не нужно объявлять типы переменных в JavaScript, в отличие от некоторых других языков программирования Если давать переменной значение числа,кавычки не используются:

Строки (‘Strings’)

Строки — это фрагменты текста. Когда вы даёте переменной значение строки, вам нужно обернуть её в одиночные или двойные кавычки, в противном случае JavaScript попытается проиндексировать её как другое имя переменной.

Логические (Booleans)

Booleans — истинные / ложные значения — они могут иметь два значения: true или false. Они обычно используются для проверки состояния, после чего код запускается соответствующим образом. Вот простой пример:

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

Здесь используется оператор «меньше» (<), чтобы проверить, является ли 6 меньше 3. В данном примере, он вернёт false, потому что 6 не меньше 3! В дальнейшем вы узнаете больше о таких операторах.

Массивы (Arrays)

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

Как только эти массивы определены, можно получить доступ к каждому значению по их местоположению в массиве. Наберите следующие строки:

Квадратные скобки указывают значение индекса, соответствующее позиции возвращаемого значения. Возможно, вы заметили, что массивы в JavaScript индексируются с нулевой отметкой: первый элемент имеет индекс 0.

В следующей статье вы узнаете больше о массивах.

Объекты (Objects)

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

Попробуйте ввести следующую строку в консоль:

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

Мы больше не будем рассматривать объекты в данном курсе — вы можете больше узнать о них в будущем модуле.

Динамическая типизация

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

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

Он всё равно будет строкой, даже если он содержит числа, поэтому будьте осторожны:

Попробуйте ввести четыре строки выше в консоль одну за другой и посмотреть результаты. Вы заметите, что мы используем специальную функцию typeof() — она возвращает тип данных переменной, которую вы передаёте в неё. В первый раз, когда она вызывается, она должа возвращать строку, так как переменная myNumber содержит строку ‘500’ . Посмотрите, что она вернёт во второй раз, когда вы её вызовите.

Подведение итогов

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

C++. Понятие переменной. Объявление переменной. Локальные и глобальные переменные. Выделение памяти для переменных. Константы

Понятие переменной. Объявление переменной. Локальные и глобальные переменные. Операция расширения области видимости :: . Выделение памяти для переменных. Константы

Содержание

Поиск на других ресурсах:

1. Что называется переменной?

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

При разработке программы, программист по собственному усмотрению дает имена переменным. Имя переменной есть именем идентификатора. Это имя должно соответствовать синтаксису языка C/C++. Более подробно об именах переменных описывается в теме:

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

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

В языке C/C++ каждая переменная должна иметь собственный тип. Более подробно о типах данных C/C++ описывается в статье:

2. Какой общий вид описания переменной в C/C++?

Общий вид описания переменной:

• тип – тип данных, соответствующий переменным из список_переменных ;
• список_переменных – перечень переменных заданного типа, разделенных запятой.

Переменная может иметь до 1024 символов любого имени.

Пример объявления переменных разных типов.

3. В каких местах программы можно объявлять переменные? Как классифицируются переменные в зависимости от места объявления в программе?

Переменные могут быть объявлены:

• внутри функций;
• в определении параметров функций;
• за пределами всех функций.

В зависимости от места объявления в программе, переменные классифицируются следующим образом:

• локальные переменные (объявляются внутри функций);
• формальные параметры (есть параметрами функций);
• глобальные переменные (объявляются за пределами функций).

4. Что такое локальные переменные? В каких местах программы объявляются локальные переменные?

Локальные переменные – это переменные, которые объявлены (описаны) внутри функций. Доступ к таким переменным имеют только операторы, которые используются в теле функции.

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

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

5. Что означает термин «разрушение переменной»?

Локальные переменные создаются в момент вызова функции. Как только выполнение функции завершается, локальные переменные разрушаются. Термин «разрушение переменной» означает: разрушение переменной в оперативной памяти после завершения функции, в которой эта переменная была объявлена.

6. Что означает термин «формальный параметр»?

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

Формальные параметры объявляются после имени функции внутри круглых скобок ( ) .

Пример. Пусть даны объявления функции GetMax3() , которая находит максимальное значение между тремя целыми числами.

В данном примере, в функции GetMax3() есть 3 формальных параметра с именами a , b , c . При вызове функции из другого программного кода ей передаются 3 числа (аргумента), которые копируются в формальные параметры. Число 8 копируется в формальный параметр a . Число 5 копируется в формальный параметр b . Число 11 копируется в формальный параметр c .

7. Что такое глобальные переменные? Какое отличие между глобальными и локальными переменными?

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

Глобальная переменная объявляется за пределами всех функций.

Пример. В данном примере объявлена глобальная переменная max и две функции GetMax2() и GetMax3() .

8. Примеры объявления переменных разных типов

9. Как выделяется память для переменных целочисленных типов?

При объявлении переменной для нее выделяется память. Размер памяти, которая выделяется, зависит от типа переменной. Размер выделенной памяти влияет на диапазон значений, которые может принимать переменная.

Для переменных целых типов выделяется память соответственно нижеследующим таблицам.

Для 16-разрядной среды.

(аналогичен типу int)

(аналогичен типу int)

(аналогичен типу unsigned int)

(аналогичен типу int)

-2 147 483 648 … 2 147 483 647

(аналогичен типу long int)

Для 32-разрядной среды.

-2 147 483 648 … 2 147 483 647

(аналогичен типу int)

-2 147 483 648 … 2 147 483 647

(аналогичен типу int)

(аналогичен типу unsigned int)

-2 147 483 648 … 2 147 483 647

(аналогичен типу signed int)

Начиная с версии C++ 11 были введены два новых целочисленных типа данных: long long и unsigned long long . При объявлении переменной одним из этих типов выделяется 64 бита (8 байт) памяти.

Диапазон значений для типа long long

Диапазон значений для типа unsigned long long

10. Как выделяется память для переменных типов с плавающей запятой?

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

11. Как выделяется память для переменных символьных ( char ) типов?

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

12. Что такое константы в языке программирования C++? Как объявить константу?

Константа – это есть переменная, которая не может изменять своего значения на протяжении всего времени выполнения программы. Значение константе присваивается при ее объявлении. Для объявления константы используется ключевое слово const.

Общий вид объявления константы

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

Примеры объявления констант.

13. Доступ к глобальным переменным всередине функций. Операция расширения области видимости :: . Пример

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

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