Как объявить переменную в с

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

тип список_переменных;

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

int i,j,l; short int si; unsigned int ui; double balance, profit, loss;

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

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

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

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

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

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

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

void func1(void) < int x; x = 10; >void func2(void)

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

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

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

Переменные. Способы объявления. Правила именования. C++ для начинающих. Урок #5.


void f(void) < int t; scanf(«%d%*c», if(t==1) < char s[80]; /* эта переменная создается только при входе в этот блок */ printf(«Введите имя:»); gets(s); /* некоторые операторы . */ >/* здесь переменная s невидима */ >

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

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

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

#include int main(void) < int x; x = 10; if(x == 10) < int x; /* эта x прячет внешнюю x */ x = 99; printf(«Внутренняя x: %dn», x); >printf(«Внешняя x: %dn», x); return 0; >

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

Внутренняя х: 99 Внешняя х: 10

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

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

/* Эта функция вызывает ошибку компиляции на компиляторе C89. */ void f(void) < int i; i = 10; int j; /* ошибка в этой строке */ j = 20; >

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

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

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

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

#include void f(void); int main(void) < int i; for(i=0; ivoid f(void) < int j = 10; printf(«%d «, j); j++; /* этот оператор не влияет на результат */ >

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

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

/* Возвращает 1, если в строке s содержится символ c, в противном случае возвращает 0 */ int is_in(char *s, char c)

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

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

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

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

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

#include int count; /* глобальная переменная count */ void func1(void); void func2(void); int main(void) < count = 100; func1(); return 0; >void func1(void) < int temp; temp = count; func2(); printf(«count равно %d», count); /* напечатает 100 */ >void func2(void)

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

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

----------

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

Комментарии

Классические комментарии в C выглядят так:

/* Привет, это комментарий */
/* Его можно начинать на одной строчке
и продолжать на другой */

Есть ещё однострочные комментарии двумя слешами //, но бывают компиляторы, которые их не понимают.

Переменные и типы данных

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

В C есть разделение на короткие (short), обычные и длинные (long) переменные — на 2, 4 и 8 байт соответственно. Это нужно для экономии памяти, чтобы выделять ровно то количество байт, которое нужно для работы программы.

int i; /* целое число на 4 байта */ int x,y; /* две целочисленные переменные */ short int si; / *короткое целое число на 2 байта */ long int l; /* целое число на 8 байт */ char c; /* символьная переменная */ float f; /* дробная переменная на 4 байта */ double d; /* дробная переменная на 8 байт */ int a [10]; /* массив из 10 целых чисел */ struct str_name; /* структура из целого числа и символа */

C Урок 4. Переменные и типы данных. Часть 1

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

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

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

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

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

Типы данных можно разделить условно на три группы:

  1. целые — данные целого типа,
  2. вещественные — данные, которые могут иметь дробную часть,
  3. символы — данные типа char, которые представляют собой какой-то символ и занимают в памяти всего один байт.

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

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

Данная таблица, думаю, всё это расскажет:

-9 223 372 036 854 775 808 …

9 223 372 036 854 775 807

Аналогичным образом ведёт себя и вещественный тип. Только представители данного типа могут иметь ещё некоторые свойства. Кроме того, что они тоже занимают в памяти каждый определенное количество байт и имеют диапазоны, они могут быть представлены ещё в нормированной форме — в виде числа, умноженного на 10 в определённой степени. Также данный вид представления называют экспоненциальной записью числа.

Например, число 135.543 можно представить как 1,35543 . 10 2 .

А, например, число 0.00001245 — как 1.245 . 10 -5 .

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

В коде мы так написать не можем, в исходном коде первое число будет выглядеть как 1.35543E2, а второе 1.245E-5.

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

Также посмотрим таблицу диапазонов и размера занимаемой памяти определённых вещественных типов

-9 223 372 036 854 775 808 .0 …

9 223 372 036 854 775 807.0

-9 223 372 036 854 775 808 .0 …

9 223 372 036 854 775 807.0

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

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

Ещё существует тип данных bool. Это целочисленный тип данных, так как диапазон допустимых значений — целые числа от 0 до 255. Данный тип используется как логический тип данных исключительно для хранения результатов логических выражений. У логического выражения может быть один из двух результатов — true или false. true — если логическое выражение истинно, false — если логическое выражение ложно. Данный тип может отсутствовать в некоторых компиляторах вообще, тогда мы используем вместо него char либо unsigned char.

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

Теперь о переменных.

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

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

Самое основное требование для объявления переменной: переменная должна быть объявлена раньше, чем она будет использоваться.

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

char symbol1;

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

Имя переменной должно быть уникальным, то есть недопустимо объявлять две переменных с одним и тем же именем.

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

Тем не менее существует и стандарт для имени переменной. Не всякие символы можно использовать в имени переменной. можно использовать буквы только латинского алфавита, как верхнего так и нижнего регистра, причём язык C является языком регистрозависимым и, например, переменные с именами Symbol1 и symbol1 — это будут разные переменные.

Также разрешается использовать арабские цифры в именах переменных (от 0 до 9), только с одним ограничением — имя переменной не должно начинаться с цифры, например имя переменной 4symbol использовать запрещено, а s4ymbol — разрешено.

В именах переменных запрещено использовать пробелы, поэтому, например, имя переменной first var запрещено. Но чтобы нам как-то можно было больше рассказать о назначении переменных и всё же использовать там несколько слов, то вместо пробелов разрешено использовать подчёркивания — ‘_’. Поэтому мы сможем нашу переменную назвать как first_var. Также со знака подчёркивания допустимо начинать имя переменной, но злоупотреблять этим нежелательно, так как во многих библиотеках, в т.ч. стандартных, переменные, имя которых начинается со знака подчёркивания, очень часто используется. Тем самым мы избежим повторения имён, которое недопустимо.

Запрещено также в качестве имён использовать ключевые слова — такие, к примеру, как if , else , int , float . Данные слова зарезервированы и не могут быть использованы.

Также не допускается использование в именах операторов (+, -, = и т.д.), кавычек, скобок и т.д.

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

Несколько переменных мы можем объявить как в разных строках

char symbol1;

int cnt;

float adc_val;

char symbol1; int cnt; float adc_val;

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

char symbol1, symbol2, symbol3;

В случае всех вышеперечисленных операций под переменные, которые мы объявили резервируется место в памяти в таком размере, какой предусматривает тип переменной, которую мы объявляем. В этом случае содержимое резервируемых ячеек памяти как правило не изменяется и значение переменной приобретёт случайную величину. Некоторые компиляторы автоматически присваивают значение 0 объявляемым переменным.

Чтобы переменная приобрела определённое значение, её следует либо инициализировать, либо присвоить ей результат какой-то операции.

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

Инициализируются переменные различными способами.

Мы можем сначала наши переменные объявить, а затем инициализировать

char symbol1, symbol2, symbol3;

int cnt;

float adc_val;

symbol1 = ‘c’ ;

symbol2 = ‘f’ ;

symbol3= ‘h’ ;

cnt = 589 ;

adc_val = 124.54 f;

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

Также мы можем проделать инициализацию наших переменных сразу — на этапе объявления

char symbol1 = ‘c’ , symbol2 = ‘f’ , symbol3= ‘h’ ;

int cnt = 589 ;

float adc_val = 124.54 f;

Оператор ‘=’ (равно) — это оператор присвоения. Используется для присвоения переменной, имя которой находится слева от оператора, значения либо результата выражения, находящегося справа от оператора.

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

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

Смотреть ВИДЕОУРОК (нажмите на картинку)

Практика

Решите предложенные задачи: Для удобства работы сразу переходите в полноэкранный режим

Исследовательские задачи для хакеров

  1. Объявите в программе переменную с неправильным именем и попробуйте скомпилировать программу. Посмотрите, какую ошибку выдаст компилятор.
  2. Найдите список всех ключевых слов языка Си. Можно искать в стандарте языка(подсказка: «keywords»), а можно в интернете. Запоминать наизусть их не нужно, но разок посмотреть на них стоит.

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

Для присваивания в языке С служит знак «=» – не путать со знаком сравнения двух чисел. При использовании данного знака производится вычисление выражение, стоящего справа от знака присваивания, и полученное значение присваивается переменной, стоящей слева от знака присваивания. При этом старое значение переменной стирается и заменяется на новое.

Примеры:
y = 6 + 8; // сложить значения 6 и 8,
// результат присвоить переменной y (записать в переменную y)

c = b + 5; // прибавить 5 к значению, хранящемуся в переменной b,
// полученный результат присвоить переменной c (записать в переменную c)

d = d + 2; // прибавить 2 к значению, хранящемуся в переменной d,
// полученный результат присвоить переменной d (записать в переменную d)

В правой части значение переменной может быть использовано несколько раз, например:

Арифметические операции

Арифметические операции языка Си представлены в таблице на следующем рисунке.

Арифметические операции в языке С

Примеры:
z = y + 7; // к значению, хранящемуся в переменной y, будет прибавлено число 7,
// полученный результат будет записан в переменную z

k = m * n; // значения переменных m и n будут перемножены,
// результат будет записан в переменную k

t = t — 1; // от значения, хранящегося в переменной t, будет отнято 1
// результат будет записан в переменную t

6.1. Исходные файлы и объявление переменных

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

При такой структуре исходной программы функции, находящиеся в разных исходных файлах могут использовать глобальные внешние переменные. Все функции в языке Си по определению внешние и всегда доступны из любых файлов. Например, если программа состоит из двух исходных файлов, как показано на рис.2., то функция main может вызывать любую из трех функций fun1, fun2, fun3, а каждая из этих функций может вызывать любую другую.

main () < . >fun1()
fun2() < . >fun3()

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

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

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

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

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

Если объект объявлен внутри блока, то он видим в этом блоке, и во всех внутренних блоках. Если объект объявлен на внешнем уровне, то он видим от точки его объявления до конца данного исходного файла.

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

Спецификатор класса памяти в объявлении переменной может быть auto, register, static или extern. Если класс памяти не указан, то он определяется по умолчанию из контекста объявления.

Объекты классов auto и register имеют локальное время жизни. Спецификаторы static и extern определяют объекты с глобальным временем жизни.

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

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

Переменная с классом памяти auto автоматически не инициализируется. Она должна быть проинициализирована явно при объявлении путем присвоения ей начального значения. Значение неинициализированной переменной с классом памяти auto считается неопределенным.

Спецификатор класса памяти register предписывает компиляторураспределить память для переменной в регистре, если это представляется возможным. Использование регистровой памяти обычно приводит к сокращению времени доступа к переменной. Переменная, объявленная с классом памяти register, имеет ту же область видимости, что и переменная auto. Число регистров, которые можно использовать для значений переменных, ограничено возможностями компьютера, и в том случае, если компилятор не имеет в распоряжении свободных регистров, то переменной выделяется память как для класса auto. Класс памяти register может быть указан только для переменных с типом int или указателей с размером, равным размеру int.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Пример: /* объявления переменной i на внутреннем уровне с классом памяти static. */ /* исходный файл file1.c */ main() { . } fun1() { static int i=0; . } /* исходный файл file2.c */ fun2() { static int i=0; . } fun3() { static int i=0; . }

Пример: /* объявления переменной i на внутреннем уровне с классом памяти static. */ /* исходный файл file1.c */ main() < . >fun1() < static int i=0; . >/* исходный файл file2.c */ fun2() < static int i=0; . >fun3()

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Пример: /* объявления переменной i, являющейся именем внешнего массива длинных целых чисел, на локальном уровне */ /* исходный файл file1.c */ main() { . } fun1() { extern long i[]; . } /* исходный файл file2.c */ long i[MAX]={0}; fun2() { . } fun3() { . }

Пример: /* объявления переменной i, являющейся именем внешнего массива длинных целых чисел, на локальном уровне */ /* исходный файл file1.c */ main() < . >fun1() < extern long i[]; . >/* исходный файл file2.c */ long i[MAX]=; fun2() < . >fun3()

Объявление переменной i[] как extern в приведенном примере делает ее видимой внутри функции fun1. Определение этой переменной находится в файле file2.c на глобальном уровне и должно быть только одно, в то время как объявлений с классом памяти extern может быть несколько.

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

1 2 3 4 5 6 7 8
Пример: main() { extern int st[]; . } static int st[MAX]={0}; fun1() { . }

Пример: main() < extern int st[]; . >static int st[MAX]=; fun1()

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

При объявлении переменных на глобальном уровне может быть использован спецификатор класса памяти static или extern, а так же можно объявлять переменные без указания класса памяти. Классы памяти auto и register для глобального объявления недопустимы.

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

1. Переменная объявлена с классом памяти static. Такая переменная может быть инициализирована явно константным выражением, или по умолчанию нулевым значением. То есть обявления static int i=0 и static int i эквивалентны, и в обоих случаях переменной i будет присвоено значение 0.

2. Переменная объявлена без указания класса памяти, но с явной инициализацией. Такой переменнойпо умолчанию присваивается класс памяти static. То есть объявления int i=1 и static int i=1 будут эквивалентны.

Переменная объявленная глобально видима в пределах остатка исходного файла, в котором она определена. Выше своего описания и в других исходных файлах эта переменная невидима (если только она не объявлена с классом extern).

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

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

В объявлениях с классом памяти extern не допускается инициализация, так как эти объявления ссылаются на уже существующие и определенные ранее переменные.

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

Объявление

В СИ семействе, как и любом другом ЯП, можно использовать разные «именованные ячейки памяти». Только сначала их требуется объявить. Для этого используются уникальные имена – идентификаторы.

Здесь стоит запомнить, что:

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

В качестве идентификатора нельзя использовать ключевые слова. Все это – ограничения, которые помогают грамотно объявлять переменные в C.

Форма «задавания» именованных ячеек в памяти для кодификации будет иметь такую запись:

Чтобы присвоить значение, потребуется после объявления переменной поставить знак равенство. Далее – прописать интересующую информацию. Пример – char c = ‘a’. Такая запись будет инициализирована символом, прописанном в кавычках.

О передаче значений

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

Здесь стоит запомнить следующие принципы:

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

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

Глобальный тип

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

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

Согласно установленным правилам синтаксиса, переменные в C типа global прописываются в самом начале утилиты. Если нужно использовать идентификаторы одного вида, к подобным «ячейкам» прибавляют префикс g_.

Ключевые слова

Связь переменной – определение, относятся ли несколько упоминаний одного идентификатора к одной и той же «ячейке памяти» или нет. Переменные без связи – локальные. Две с одинаковыми именами, но объявленные в пределах разных функций, не будут связаны между собой. Каждая – это самостоятельная единица. Также стоит запомнить, что:

  1. Переменные со внутренними связями – статические или внутренние. Они могут применяться в любом месте документа, где определены. К чему-то за пределами соответствующего документа оные не имеют никакого отношения.
  2. Если у переменной есть внешние связи – это внешние «ячейки памяти». Они применяются как в файле, где определены, так и за их пределами.
  3. Чтобы сделать глобальную переменную внутренней, используется ключевое слово static.
  4. Для внешних «ячеек» необходимо применить extern.

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

Область видимости

В C++ есть несколько «неофициальных» понятий, которые могут запутать новичка. Это – файловая и глобальная области видимости.

У глобальных переменных в рассматриваемом языке «стандартно» тип области видимости – файловый. Но данное понятие чаще применяется к внутренним глобальным переменным, а «глобальная область видимости» — к внешним global.

Чтобы лучше понимать эти термины, стоит рассмотреть приложение:

Переменные для языка программирования С++ Переменные для языка программирования С++

  1. G_y – это файловая область видимости в пределах global.cpp.
  2. Доступ к g_y за пределами соответствующего документа отсутствует.
  3. В main.cpp компилятор не увидит оную. Он сможет распознать предварительное объявление g_y.
  4. Линкер будет отвечать за связь определения g_y в global.cpp с использованием g_y в main.cpp.

Обычно соответствующие понятия встречаются в отношении больших утилит.

Символьные

Глобальные переменные в C ++ могут быть символьными константами. Они определяются так:

Переменные для языка программирования С++

Это – хороший вариант для небольших утилит. Каждый раз, когда представленный документ (constants.h) подключается в другой файл, каждая переменная будет туда копироваться. Присоединить удастся до 20 документов. Тогда каждая из переменных продублируется двадцать раз.

Чтобы избежать подобной ситуации, можно превратить предложенные константы в тип констант «глобальные переменные». Далее – изменить заголовочный документ только для хранения предварительных объявлений «ячеек памяти».

Переменные для языка программирования С++

Тут определение символьных canst выполняется в constants.cpp один раз. Все корректировки потребуют перекомпиляции одного файла.

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

Оцените статью
TutShema
Добавить комментарий