Переменная это именованная область жесткого диска

Обновлено: 01.07.2024

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

1.1. Тип данных определяет размер и размещение переменной в памяти.

1.2. Основная форма объявления переменной:

тип данных переменная [ = значение], [переменная [= значение], . ] ;

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

1.3. Существует три типа переменных:

- локальные переменные
- переменные экземпляра
- статические переменные или переменные класса

1.3.1. Локальные переменные объявляются в методах, конструкторах или блоках (далее МКБ). Они создаются, когда МКБ запускается; уничтожаются после его завершения; видны только в его пределах. Для них нельзя использовать модификаторы доступа. Реализуются на уровне стека. Для них не существует значения по умолчанию.

1.3.2. Переменные экземпляра объявляются в классе, но за пределами МКБ. Создаются тогда, когда объект создан (ключевое слово new); уничтожаются вместе с ним; являются видимыми для всех МКБ в классе. Внутри класса доступны через имя переменной; в статических методах и других классов — через полное имя (ObjectReference.VariableName). Возможно использование модификаторов доступа. В них хранятся значения, на которые должен ссылаться более одного МКБ; а также основные состояния объекта. Когда для объекта выделяется пространство в стеке, для переменной экземпляра создается соответствующий ей слот. Они имеют значения по умолчанию (для чисел это 0, для логических false, для ссылок на объект null.

1.3.3. Переменные класса (они же статические переменные) объявляются с ключевым словом static в классе, но за пределами МКБ. Создаются при запуске программы; уничтожаются при ее завершении. Видимость аналогична переменной экземпляра, но часто рекомендуется модификатор public, т.к. обычно они используются как константы и должны быть доступны пользователям класса. Константы - переменные, которые объявлены как public/private, final и static. Константы никогда не меняются от первоначального значения. Значения по умолчанию аналогичны переменным экземпляра. Значения могут быть присвоены также в специальных блоках статического инициализатора, код которых выполняется при первой загрузке класса.

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

Объяснение:

Зависит от парадигмы программирования.

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

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

Переменные изменяются во времени и зависят от предыдущих своих значений. Оператор присваивания.

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

Функциональный подход базируется на понятиях лямбда-исчисление и функции высших порядков. Этот подход мыслит программу как некое математическое описание, исчисляемую запись. Переменные при таком подходе мыслятся именно с математической точки зрения. Они зовутся переменными, так как подразумевают некое многообразие значений, которые могут принять, но по факту во время исполнения, получив конкретное значение, становятся константами. Тут нет оператора присваивания в обычном понимании.

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

Рассмотрим на примере языка Prolog. Например, мы можем сказать "Кот - животное, которое мало, пушистое и мяукает. А собака - это пушистик, который гавкает." (это не обязательно должно быть так, но ведь нам ничего не мешает сказать так?) и записать это как:

cat(animal(Size, Fluffy, Sounds)) :- Size="small", Fluffy=true, Sounds="Nya!".
dog(animal(_, Fluffy, Sounds)) :- Fluffy=true, Sounds="Wow!"

Переменные в данном случае нужны не для того, чтобы хранить значения. Они определяют "пути" или "каналы", по которым "текут" данные (при чём течь они могу в любую сторону). Они позволяют разобрать комплексный объект на признаки и рассмотреть их. Операция " small", Y = true, Z = "Nya!", а сам предикат cat вернёт true.

Я могу, вызвать и так:

и получу X = "small", Z = "Nya!", а сам предикат cat вернёт true.

и получу в ответе false.

Так работают переменные в логической парадигме.

Вывод: понятие "переменная" в программировании - комплексное и его конкретное представление зависит от парадигмы программировании, в рамках которой оно рассматривается. В процедурном подходе переменная - именованная область памяти компьютера. В функциональном подходе переменная мыслится как математическая переменная со всеми её свойствами. В логическом подходе переменная - способ задать пути преобразования комплексных объектов и задать пути "течения" данных. Объединяет эти взгляды то, что понятие "переменная" тесно связана с понятием "данные".

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

Именем («обозначением ячейки памяти»)
Значением (данными, содержащимися в переменной в конкретный момент времени)
Типом (определяющим: а) какие значения может принимать переменная; б) какие операции можно производить с этими значениями; в) как данные представлены в памяти компьютера)

Имена и типы переменных указываются в разделе описаний и не могут изменяться в процессе выполнения программы.

Дискретные (можно перечислить возможные значения):

целые (integer, longint)
символьный (char)
логический (boolean)
диапазон (часть значений стандартного дискретного типа, например, 1..100)
перечисляемый (явно перечислены все допустмые значения)

Вещественные (real, double, extended) — служат для представления действительных чисел с ограниченной точностью.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Презентацию к данной лекции Вы можете скачать здесь.

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

Пример описания целой переменной с именем a и вещественной переменной x :

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

переменная a типа int , начальное значение которой не присваивается;
переменная b типа int , ее начальное значение равно 1;
переменные х и y типа float , которым присвоены одинаковые начальные значения 0.1. Разница между ними состоит в том, что для инициализации переменной х сначала формируется константа типа double , а затем она преобразуется к типу float ; переменной y значение 0.1 присваивается без промежуточного преобразования.

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

В листинге 3.1 приведен пример программы, в которой описываются и выводятся на экран локальные переменные.

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

Операции и выражения

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

Операции в выражении выполняются в определенном порядке в соответствии с приоритетами, как и в математике. В таблице 3.1 операции расположены по убыванию приоритетов, уровни приоритетов разделены в таблице горизонтальными линиями.

Результат вычисления выражения характеризуется значением и типом. Например, пусть a и b — переменные целого типа и описаны так:

Тогда выражение a + b имеет значение 7 и тип int , а выражение a = b имеет значение , равное помещенному в переменную b (в данном случае — 5) и тип, совпадающий с типом этой переменной.

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

Например, a + b + c означает (a + b) + c , а a = b = c означает a = (b = c) .

Преобразования встроенных арифметических типов-значений

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

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

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

Арифметические операции не определены для более коротких, чем int , типов. Это означает, что если в выражении участвуют только величины типов sbyte , byte , short и ushort , перед выполнением операции они будут преобразованы в int . Таким образом, результат любой арифметической операции имеет тип не менее int .

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

Рис. 3.2. Неявные арифметические преобразования типов

Введение в исключения

Например, при делении на ноль будет сгенерировано исключение DivideByZeroException , при недостатке памяти — исключение OutOfMemoryException .

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

Здесь тип означает один из базовых или объявленных программистом типов (если необходимо — с одним или несколькими спецификаторами), а список_переменных состоит из одного или более идентификаторов, разделенных запятыми. Ниже приведены примеры объявлений:

Необходимо помнить, что в С имя переменной никогда не определяет ее тип.

Где объявляются переменные

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

Переменные, объявленные внутри функций, называются локальными переменными . В некоторых книгах по С они называются динамическими переменными [2] . В этой книге используется более распространенный термин локальная переменная . Локальную переменную можно использовать только внутри блока, в котором она объявлена. Иными словами, локальная переменная невидима за пределами своего блока. (Блок программы — это описания и инструкции, объединенные в одну конструкцию путем заключения их в фигурные скобки.)

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

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

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

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

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

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

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

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

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

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

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

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

Локальные переменные можно инициализировать каким-либо заранее заданным значением. Это значение будет присвоено переменной каждый раз при входе в тот блок программы, в котором она объявлена. Например, следующая программа напечатает число 10 десять раз:

Формальные параметры функции

Если функция имеет аргументы, значит должны быть объявлены переменные, которые примут их значения. Эти переменные называются формальными параметрами функции. Внутри функции они фигурируют как обычные локальные переменные. Как показано в следующем фрагменте программы, они объявляются после имени функции внутри круглых скобок:

Функция is_in() имеет два параметра: s и с , она возвращает 1, если символ, записанный в переменной с , входит в строку s , в противном случае она возвращает 0.

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

Глобальные переменные

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

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

Внимательно посмотрите на эту программу. Обратите внимание на то, что ни в func1() , ни в func2() нет объявления переменной count , однако они обе могут ее использовать. В func2() эта возможность не реализуется, так как в ней объявлена локальная переменная с тем же именем. Когда внутри func2() происходит обращение к переменной count , то это будет обращение к локальной, а не глобальной переменной. Таким образом, выполняется следующее правило: если локальная и глобальная переменные имеют одно и то же имя, то при обращении к ней внутри блока, в котором объявлена локальная переменная, происходит ссылка на локальную переменную, а на глобальную переменную это никак не влияет.

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

[1] Называется также описанием или декларацией .
[2] А в книгах по C++ переменной автоматического класса памяти (т.е. такой, что создается при входе в блок, где она объявлена, и уничтожается при выходе из него).

Читайте также: