Советы и лайфхаки

С объявление переменных – Объявление переменных | Программирование на C и C++

Переменные в языке Си. Объявление переменных в Си.

Пожалуйста, приостановите работу AdBlock на этом сайте.



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

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

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

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

Рис.1. Общий синтаксис объявления переменной.».

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

Ещё парочка примеров:

Листинг 1. Объявление переменных

int z;  // переменная z  целого типа
char w; // переменная w символьного типа

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

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

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

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

Peremennaya, flag, f3, var4, KolichestvoBukv, fd4s, FLaG, key_number

Неправильные имена переменных

2num – начинается с цифры
num flat – содержит пробел в имени
nomer-telefona – содержит дефис

И ещё один важный момент. В языке программирования Си регистр букв очень важен. Например, переменные с именами flag, FLAG, FlAg, fLAg — это всё различные переменные. Кроме того, есть ряд слов, которые нельзя использовать для названия переменных. Например, int, void, return и другие. Это специальные ключевые слова, которые зарезервированы для нужд самого языка и нигде в другом месте не могу быть использованы.

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

Листинг 2. Объявление нескольких переменных

int a,c; // объявляем переменные a и c целого типа
double x, y, z; // объявляем сразу три вещественные переменные 

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

Переменная в памяти компьютера.

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

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

Листинг 3. Объявление двух переменных

int w; // объявляем целочисленной переменной w
double z; // объявляем вещественной переменной z 

Рис.3. Переменные в памяти компьютера.

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

youngcoder.ru

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

Каждая
переменная перед её использованием в
программе на языке С++
должна быть объявлена,
т. к. для неё должна быть выделена память,
размер которой и её содержимое зависят
от
типа,
указанного в объявлении. Так, переменной
типа char
выделяется
1 байт,
int

4 байта, float

4 байта
,
double

8 байтов, bool
– 1 байт. Объявление
переменной состоит из названия её типа
и имени:

int
x; //
объявление переменной x
типа
int

double
f; // объявление переменной f
типа double

В
объявлении можно указать несколько
переменных, разделив их запятыми:

int
i, j, k; //
объявление целых переменных i,
j
и k

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

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

int
num
= 5; // объявление переменной num
типа int

//
с начальным значением 5

int
m
= 3, n
= 5; // объявление целых переменных m
и n
с

//
начальными значениями 3
и 5
соответственно

double
d1
= 5.5; // объявление переменной d1
типа double

//
с начальным значением 5.5

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

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

int
i = 1, j, k = 2; // объявление целых переменных
i и
k с

//
начальными
значениями 1
и 2;

//
и целой переменной j
без начального значения

Константы

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

Константой
называется
величина, значение которой во время
выполнения программы
нельзя

изменить.

Неименованные константы

Обычно
константы задаются в программах своими
конкретными значениями (неименованные
константы

или просто литералы).
Например, в записи k
+ 34

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

Числовые
константы
разделяют
на целые
и вещественные.

Целые:

десятичные
типа
int:
0, -64, 493 – используются целые 10
цифры;

шестнадцатеричные:
0x0001,
0x16,
0XFA – используются
шестнадцатеричные
цифры, запись числа начинается с 0x
или 0X;

восьмеричные:
00, 012, 0777 – используются восьмеричные
цифры, запись числа начинается с нуля.

Вещественные
типа double
:

запись
числа 3.14 эквивалентна 314e-2, а также –
0.314E1;

запись
числа -2.5 эквивалентна -0.25E+1.

По
форме записи числовой
константы

компилятор определяет её тип. По
умолчанию

целые десятичные числа имеют тип int,
вещественные – double,
если
они принадлежат соответствующим
множествам значений указанных типов.

Тип
числовой константы можно задать явно
с помощью суффиксов:

u,
l,
h,
U,
L,
H
– для целых; l,
f,
L,
F
– для вещественных.

Например:
45L
– константа
типа
long
int
;
115UH
unsigned
short
;
3.5f
float;
1.2E+4L
long
double
.

Для
обработки констант компилятор С++
использует допустимые типы данных с
наименьшим возможным диапазоном
значений, поскольку осуществляется
оптимизация по памяти. Например, для
хранения в памяти константы 1245
или -234
будет использован тип short
(или int,
если он в данной ОС
занимает 2
байта). Но если требуется, чтобы под
константу было отведено столько памяти,
сколько объявлено, а не столько, сколько
фактически она занимает, необходимо
тип
числовой константы

задать явно с помощью суффиксов:
234L,
3.14159f.

Символьная
константа
– символ в ограничивающих его одинарных
кавычках, например: ‘D’, ‘9’, ‘s’, ‘+’, ‘y’, ‘\n’,
‘\\’.

Строковая
константа
(или
строка
)

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

«\n\t
Massiv
chisel\n»

studfiles.net

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

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

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

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

main
()
{ …
}
fun1()
{ …
}

.

fun2()
{

}
fun3()
{ …
}

file1.c

file2.c

Рис.2.
Пример программы из двух файлов

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:
main() { extern int st[]; … } static int st[MAX]={0}; 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, может быть определена
только один раз в одном из исходных
файлов программы.

studfiles.net

c++ — С++ Объявление переменных класса в заголовке или .cpp?

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

В традиционном смысле современные методы дизайна классов рекомендуют вам притворяться, что они «черные ящики»: все идет, они могут выполнять определенные задачи, возможно, выводить некоторую другую информацию. Мы делаем это с помощью методов класса все время, кратко описывая их подпись в файле .h/.hpp/.hxx и скрывая детали реализации в файле .cpp/.cc/.cxx.

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

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

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

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

Если вам нужно зарезервировать память/построить что-то и связать ее с именем переменной, всегда старайтесь сделать это в исходном файле.

qaru.site

1С объявление переменных

Переменные

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

Могут быть произвольного допустимого в рамках 1С и контекста типа.

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

Под «контекстом» будет подразумеваться модуль и окружение которому этот модуль принадлежит.

В примерах используется комментирование кода 1С.

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

Явное объявление переменных в 1с, в общем случае, не обязательно и может производится непосредственно перед использованием.

Для явного используется служебное имя «Перем«, которое регистронезависимое (допустимо использование, например»ПеРЕМ«).

Примеры явного объявления переменной:

// обычная переменная
Перем МояПеременная1;
// экспортная переменная
Перем МояВидимаяПеременная2 Экспорт;

Пример объявления в функции:

В данном случае мы видим две переменные :

  • «ПараметрФункции«, которую нам передали при вызове, она объявлена в месте вызова, и возможно с другим именем.
  • «ПеременнаяФункции1» — новая переменная, которая действует только в рамках функции
Функция НекаяФункция(ПараметрФункции)
    Перем ПеременнаяФункции1;
    //Далее код
КонецФункции

Именование переменных

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

Не могут начинаться на цифру, но могут ее содержать.

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

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

Имя должно быть понятным, запоминаемым. Допускается использование префиксов для удобства восприятия, например: лЛокальнаяПеременная, фПеременнаяФормы.

Обычно применяется выделение регистром для визуального осмысления: ВременнаяПеременнаяДляХраненияПромежуточныхРасчетов

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

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

Платформа инициализирует переменные значением «Неопределено» по умолчанию

В момент объявления переменные явно присвоить значение возможно только, если это параметр функции

В примере ниже:

  • ПараметрфункцииИнициализируемый — если не передан параметр в функцию он будет инициализирован строковым значением 123
  • ПеременнаяФункции2 — переменная инициализирована после объявления
  • ПеременнаяФункции3 — переменная инициализирована по имени и значением, без явного объявления
Функция НекаяФункция(ПараметрФункцииИнициализируемый="123")
    Перем ПеременнаяФункции2;
    ПеременнаяФункции2 = 321;
    ПеременнаяФункции3 = "321Пуск";
КонецФункции

Последний вариант ничем не хуже второго и повсеместно используется, но явная инициализация, признается более «правильной«

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

Допустимо не переопределять значение «Неопределено«, т.к. всегда можно проверить тип значение или содержимое

Видимость переменных

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

  • под контекстом в данном случае понимается модуль текущего объекта
  • в некоторых модулях допустима инициализация переменных в начале, что позволит использовать переменных неограниченно в любой точке данного модуля (модуль приложения, формы, объекта и другие)
  • в других такое недопустимо (модуль команды, модуль веб-сервисов)
  • допустима передача значений или ссылки на значение переменой в функции(процедуры)
  • к экспортным переменным допустимо обращение из других объектов (модулей, объявляются служебным регистронезависимым словом «Экспорт» через пробел от имени)
Передача значений переменных
  • Не ограничивается передача значений внутри  процедуры или функции
  • Передача значений между процедурами внутри модуля объекта, допустимо при совместимых местах исполнения («клиент<->клиент»,»сервер<->сервер»)
  • Ограниченная передача при несовместимых местах выполнения кода или передача в другие объект
    • примитивные типы: строка, число, дата переносятся без ограничений
    • объектные типы и коллекции переносятся, если в среде возможно использование данных типов, либо не запрещается их передача («мутабельные» типы)

Более подробно на последнем случае останавливаться не буду, т.к. это один уроков, который вы должны пройти самостоятельно. Система вам сообщит, когда вы наступите на «грабли«, а объяснить простыми не получится.

В случае, если вам все-таки требуется передать значение, необходимо:

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

Конвертация значений будет рассмотрена в других разделах.

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

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

— Фредерик Бегбедер

capitally.ru

Объявление переменных в программе. — КиберПедия

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

float f = x + y ;

В программе можно использовать константы. В отличие от переменной, константа не меняет свое значение в программе. Описание константы начинается со слова const.При объявлении переменной можно указать ее тип, иначе он будет определен автоматически. Т.к. в программировании важную роль играют 8 и 16 системы счисления, можно использовать 8 и 16-ричные константы. Восьмеричная константа начинается с цифры 0, шестнадцатеричная: 0х. например, 016, 01677 ― 8-ичные константы, 0х16, 0хА3В, 0xFFFF ― 16-ичные константы.

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

<тип_переменой> <имя_переменной>

Основные типы переменных

Тип Диапазон значений Размер в байтах
char(символ) -128 . . . 128 Обычно используется для хранения букв
int(целый) -32768 … 32767
unsigned(целый без знака) 0 … 65535
long(длинный целый) -2147483648 … 2147483647
float(вещественный) -3. 4E-38 … 3. 4E38
Double(двойной вещественный) 1.7E-308 … 1. 7E308

E означает 10 в степени

Пример.

int x, y, sum;

float radius;

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

Оператор присваивания = знак «равно»

age =17; a=2; a=a*a; i=i+1 ;

При объявлении переменной ей можно присваивать начальное значение (инициализировать)

int age=17;

float distance =238857;

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

If (( f = x―y) > 0) cout << ²число х больше, чем у ²;

Еще одна особенность использования оператора присваивания:

a = b = c = x*y


Этот оператор выполняется справа налево.

Также имеются дополнительные операции присваивания: += — = /= *= % =

n = n + 5 аналогично n +=5

Здесь += аддитивная операция присваивания, в результате выполнения которой величина, стоящая справа прибавляется к значению переменной, стоящей слева

m -=20 m=m-20

m *=20 m=m*20

m /=20 m=m/20

m %=20 m=m%20

Операция х +=5 выполняется быстрее, чем х =х+5

Ввод с клавиатуры.

Для чтения ввода с клавиатуры используется входной поток cin, который является объектом класса istream (входной поток). При использовании cin необходимо указать переменную, в которую cin поместит данные. В cin используется оператор извлечения >> , который извлекает данные из входного потока.

Пример.

#include <iostream. h>

void main(void)

{

int a, b;

char simvol;

cout << ²введите два числа и нажмите enter: ² ;

cin >> a >> b;

cout << ²были введены числа: ² << a << b << endl;

cout << ²введите любой символ и нажмите enter: ²;

cin >> simvol;

cout << ² был введен символ ² << simvol << endl;

}

 

В текст программы необходимо включать комментарии. Комментарий в С++ начинается с / /. Когда компилятор встречает двойной слэш, он игнорирует весь текст в текущей строке, который следует за / / . Также можно заключать комментарий в символы /* */, такой комментарий может охватить несколько строк. Можно использовать пустые строки для разделения операторов. Пустые строки компилятор пропускает.

Основные операции

Математические: Сложение + вычитание —

умножение * деление / % остаток от целочисленного деления

Операция увеличения на 1 : + + (инкремент)

Операция уменьшения на 1 — — (декремент)

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

а = а + 1, или а++, или a+=1

Существует префиксная(до) и постфиксная(после) операции увеличения

Пример:

а = b++; или a = b;

b = b + 1; постфиксная

a = ++b; или b = b + 1;

a = b; префиксная

Существуют аналогичные операции уменьшения.

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


Постфиксные операции сначала используют значение переменной, а затем увеличивают или уменьшают его.

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

11 / 3 = 3 1 / 2 = 0

Для того, чтобы получить вещественное число, следует в записи числа использовать десятичную точку: 1. / 2. = 0.5

=> pow (x+y , 1. / 4.) или pow (x + y, 0.25)

Другие операции С++ и порядок их выполнения

Операция имя пример
[ ] индексация a [ i ]
( ) вызов функции sin(x), main(void)
sizeof размер типа sizeof(int)
++ приращение после a++
++ приращение до ++a
уменьшение после a—
уменьшение до —a
& адрес объекта &a
* разыменование *a
~ Дополнение, инвертирует биты значений ~a
! логическое НЕ !a
* умножение a * b
/ деление a / b
% остаток от целочисленного деления a % b
+ сложение a + b
вычитание a — b
<< сдвиг влево; сдвигает биты значения влево на указанное количество разрядов a<<1
>> сдвиг разрядов вправо a>>1
& побитовое И a&b
| побитовое ИЛИ a | b
^ побитовое исключающее ИЛИ a ^ b
&& логическое И a&& b
| | логическое ИЛИ a | | b
< меньше, чем a<b
> больше, чем a>b
= = равно a= = b
! = не равно a !=b

 

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

cyberpedia.su

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

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

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

main () { … } fun1() { … } . fun2() { … } fun3() { … }
file1.c file2.c
Рис. Пример программы из двух файлов

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример: объявление переменной i на внутреннем уровне с классом памяти static.

/* исходный файл file1.c */


main() { … } fun1() { static int i=0; … } /* исходный файл file2.c */ fun2() { static int i=0; … } fun3() { static int i=0; … }

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

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

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

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


/* исходный файл file1.c */ main() { … } fun1() { extern long i[]; … } /* исходный файл file2.c */ long i[MAX]={0}; fun2() { … } fun3() { … }

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

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

Пример:


main() { extern int st[]; … } static int st[MAX]={0}; 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, может быть определена только один раз в одном из исходных файлов программы.

Объявления функций

Функции всегда определяются глобально. Они могут быть объявлены с классом памяти static или extern. Объявления функций на локальном и глобальном уровнях имеют одинаковый смысл.

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

1. Функция, объявленная как static, видима в пределах того файла, в котором она определена. Каждая функция может вызвать другую функцию с классом памяти static из своего исходного файла, но не может вызвать функцию, определенную с классом static в другом исходном файле. Разные функции с классом памяти static имеющие одинаковые имена могут быть определены в разных исходных файлах, и это не ведет к конфликту.

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

3. Если в объявлении функции отсутствует спецификатор класса памяти, то по умолчанию принимается класс extern.

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

Похожие статьи:

poznayka.org

Отправить ответ

avatar
  Подписаться  
Уведомление о