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

Для создания переменной — используется

операция объявления.
Объявление переменной задаёт имя и атрибуты переменной.
Атрибутами переменной могут быть тип, количество
элементов (для массивов), спецификация класса памяти, а
также инициализатор.
Инициализатор – это константа соответствующего типа,
задающая значение, которое присваивается переменной при
создании.
Переменная может быть инициализирована только после
операции объявления.
Объявление переменной имеет следующий синтаксис:
[<спецификация класса памяти>] <тип> <имя> [=
<инициализатор>] [,<имя> [= <инициализатор>] ...];
Примеры объявления переменных

static int i;
double x=8, y = exp(x);
int a, b = 0;
char d = 's';
bool k = true;
float b;
 Классы памяти
Каждая переменная характеризуется
некоторым классом памяти, которая
определяет ее время жизни — период, в
течение которого эта переменная
существует в памяти.

В C++ имеется четыре спецификации

класса памяти: auto, register, extern и
static. Спецификация класса памяти
идентификатора определяет класс
памяти, область действия и
пространство имен.
Областью действия (областью видимости)
идентификатора называется область
программы, в которой на данную переменную
(как, впрочем, и на идентификатор, константу,
функцию и т.п.) можно сослаться.
Класс памяти определяется, в частности,
местом объявления переменной.
Локальные переменные объявляются внутри
некоторого блока или функции. Эти
переменные видны только в пределах того
блока, в котором они объявлены.
Глобальные переменные объявляются вне
какого-либо блока или функции (в том числе и
main).
Спецификации класса памяти могут быть
разбиты на два класса: автоматический
класс памяти с локальным временем
жизни и статический класс памяти с
глобальным временем жизни.
•Ключевые слова auto и register
используются для объявления
переменных с локальным временем
жизни. Эти спецификации применимы
только к локальным переменным.
Локальные переменные создаются при
входе в блок, в котором они объявлены,
существуют лишь во время активности
блока и исчезают при выходе из блока.
Спецификации могут указываться перед
типом в объявлении переменных.
Например: auto float x, у;
Локальные переменные являются
переменными с локальным временем жизни
по умолчанию. Пусть, например, имеется
следующий фрагмент кода:
{ int i = 1;… і + +; …}
к которому в ходе работы программы
происходит неоднократное обращение. В
такой локальной переменной невозможно
хранить какую-то информацию между
двумя обращениями к блоку.
Модификатор register рекомендует
компилятору разместить локальную
переменную в регистре процессора, если
это возможно.
Например: register int i = 1;
Если интенсивно используемые
переменные, такие как счетчики или
накапливаемые суммы могут сохраняться в
аппаратных регистрах, накладные расходы
на повторную загрузку переменных из
памяти в регистр и обратную загрузку
результата в память могут быть исключены.
Компилятор может проигнорировать
объявления register.
•Ключевые слова extern и static используются,
чтобы объявить идентификаторы переменных
как идентификаторы статического класса
памяти с глобальным временем жизни. Такие
переменные существуют с момента начала
выполнения программы. Для таких
переменных память выделяется и
инициализируется сразу после начала
выполнения программы.
Существует два типа переменных статического
класса памяти: глобальные переменные и
локальные переменные, объявленные
спецификацией класса памяти static.
Глобальные переменные по умолчанию
относятся к классу памяти extern.
Глобальные переменные создаются путем
размещения их объявлений вне описания
какой-либо функции и сохраняют свои
значения в течение всего времени выполнения
программы. На глобальные переменные может
ссылаться любая функция, которая
расположена после их объявления или
описания в файле.
double x; // глобальная переменная
int main() {
double y; // локальная переменная
...
}
Локальные переменные, объявленные с
ключевым словом static, известно
только в том блоке, в котором они
определены.
Но в отличие от автоматических
переменных, локальные переменные
static сохраняют свои значения в
течение всего времени выполнения
программы. При каждом следующем
обращении к этому блоку локальные
переменные содержат те значения,
которые они имели в предыдущем
обращении.
{
static int i = 1;
…
i + +;
}
Статическая переменная способна хранить
информацию между обращениями к блоку и,
следовательно, может пользоваться, например, как
счетчик числа обращений.
Все числовые переменные статического класса памяти
принимают нулевые начальные значения, если
программист явно не указал другие начальные
значения. Статические переменные — указатели, тоже
имеют нулевые начальные значения.
{
static int i;
…
i + +;
}
Спецификации класса памяти extern
используются в программах с несколькими
файлами. Пусть, например, в модуле Unit1 в
файле Unit1.cpp или Unit1.h (это безразлично)
объявлена глобальная переменная
int a = 5;
Тогда, если в другом модуле Unit2 в файле
Unit2.cpp или Unit2.h, объявлена глобальная
переменная
extern int a;
то компилятор понимает, что речь идет об
одной и той же переменной. И оба модуля
могут с ней работать. Для этого даже нет
необходимости связывать эти модули
директивой #include, включающей в модуль
Unit1 заголовочный файл второго модуля.
 ОПЕРАЦИИ ЯЗЫКА С++
Любое выражение языка состоит из операндов (переменных,
констант и др.), соединенных знаками операций. Знак
операции - это символ или группа символов, которые
сообщают компилятору о необходимости выполнения
определенных арифметических, логических или других
действий.
Операции выполняются в строгой последовательности.
Величина, определяющая преимущественное право на
выполнение той или иной операции, называется
приоритетом. Порядок выполнения операций может
регулироваться с помощью круглых скобок.
Различают унарные, бинарные и тернарные операции.
У первых из них один операнд, у вторых – два, а у третьих -
три.
•Арифметические операции.
•Логические операции и операции отношения.
 Арифметические операции
Арифметические операции задаются
следующими символами: * / % + -
Операция % возвращает остаток от деления и
применятся только к переменным целого типа.
Например:
int c, d, a = 5, b=2;
float x ,y , z= -1.5;
z = -z; //z=1.5
c = a / b; //c=2
d = a % b; // d=1
x=z+a; y = a/b; //y=2.0
 Операции инкремент (++) и декремент (--)
Они предназначены для увеличения и уменьшения на единицу
значения операнда. Операции ++ и -- можно записывать как перед
операндом (префиксная запись), так и после него (постфиксная
запись). В первом случае (++n или --n) значение операнда (n)
изменяется перед его использованием в соответствующем
выражении, а во втором (n++ или n--) - после его использования.
int b = b1 = 2, c = c1 = 4, i=5;
a = b + c++; ++i; // b=2, a=6, c=5, i=6
a1 = b1 + ++ c1; //b1=2, c1=5, a1=7
a1 = b1 +++ c1; //c1=4, a1=6, b1=3
int x = 5, y = 5;
cout << x << " " << y << endl;
cout << ++x << " " << --y << endl; // версия префикс
cout << x << " " << y << endl;
cout << x++ << " " << y-- << endl; // версия постфикс
cout << x << " " << y << endl;
Логические операции и операции отношения
В языке С нет специального логического или
булева типа данных. В языке С++ есть
логический тип bool.
Для представления логических значений
используются целочисленные типы. Нулевое
значение считается ложным (false), любое
ненулевое — истинным (true).
Операции отношения служат для сравнения
(больше — меньше) или проверки на равенство
двух операндов.
Операции возвращают “логическое” значение,
т. е. ненулевое целое в случае, если условие
отношения удовлетворяется, и нулевое в
противном случае
 В языке Си есть следующие операции сравнения:
операция Результат Пример:
int a = 10;
int b = 4;
== Возвращает 1, если оба операнда равны, и 0, int c = a == b; // 0
"равно» если они не равны bool L = a == b; // false
!= Возвращает 1, если первый операнд не равен int c = a != b; // 1
"не равно» второму, и 0, если оба операнда равны int d = 4 != 4; // 0
> Возвращает 1, если первый операнд больше int c = a > b; // 1
"больше второго, и 0, если первый операнд меньше
чем". второго

< Возвращает 1, если первый операнд меньше int c = 10 < 4; // 0

"меньше второго, и 0, если первый операнд больше bool L = a < b; // false
чем". второго

<= Возвращает 1, если первый операнд меньше int c = 10 <= 4; // 0

"меньше или равен второму, и 0, если первый операнд
или равно» больше второго
>= Возвращает 1, если первый операнд больше int c = 10 >= 4; // 1
"больше или или равен второму, и 0, если первый операнд bool L = a > b; // true
 Логические операции
Логические операции принимают в
качестве операндов выражения
скалярных типов и возвращают
результат булева типа:
true (1) или false (0).

Обозначение Операция Пример

! Отрицание !А
&& Логическое И А && В
|| Логическое ИЛИ А || В
Унарная операция логического отрицания
(!) возвращает true, если операнд
возвращает ненулевое значение. Таким
образом, выражение !А эквивалентно
выражению А ==0.
Операция логического И (&&) возвращает
true, если оба ее операнда возвращают
ненулевые значения. Если хотя бы один
операнд возвращает 0 (false), то операция
&& также возвращает false. Поэтому для
сокращения времени расчета, если
первый операнд возвращает нуль, то
второй операнд даже не вычисляется.
Операция логического ИЛИ ( || )
возвращает true, если хотя бы один ее
операнд возвращает ненулевое значение.
Если оба операнда возвращают 0 (false),
то операция ИЛИ также возвращает false.
Для сокращения времени расчета, если
первый операнд возвращает ненулевое
значение, то второй операнд даже не
вычисляется.
Операции && и || работают в соответствии
со следующей таблицей, где Е1 и Е2 —
сравниваемые операнды:
операция Результат Пример:
! Если операнд равен 0, то возвращает 1, int c = !2; // 0
отрицание иначе возвращает 0. int d = !0; // 1
&& Возвращает 1, если оба операнда не int c = -2 && 5; // 1
конъюнкция, равны 0. Возвращает 0, если хотя бы int d = 0 && 7; // 0
логическое один операнд равен 0.
умножение
|| дизъюнкция, Возвращает 1, если хотя бы один int c = -2 || 5; // 1
логическое операнд не равен 0. Возвращает 0, если int d = 0 || 7; // 1
сложение оба операнда равны 0. int e = 0 || 0; // 0
1. #include <stdio> 1. #include <stdio>
2. #include <string> 2. #include <string>
3. using namespace std;
3. int main() 4. int main()
4. { 5. {
5. int a = -2 > 5; 6. int a = -2 > 5;
6. int b = 0 < 7; 7. int b = 0 < 7;
7. int c = 0 == 0; 8. int c = 0 == 0;
8. int d = a && b || c; 9. int d = a && b || c;

9. std:: printf("a = %d \n", a); 10. printf("a = %d \n", a);

10. std:: printf("b = %d \n", b); 11. printf("b = %d \n", b);
11. std:: printf("c = %d \n", c); 12. printf("c = %d \n", c);
12. std:: printf("d = %d \n", d); 13. printf("d = %d \n", d);
13. } 14. }
X [-3;4] или X [7;9]
(Х >=-3 && X<=4) || (Х >=7 && X<=9)

X[4;7] - Х >=4 && X<=7

X [4;7] - Х <=4 || X>=7

Операции сравнения имеют больший
приоритет, чем логические операции
int d = -2 > 5 && 0 < 7 || 0 == 0; // 1
ложь истина истина
 Битовые операции

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

операции над битами целых чисел. В отличие от обычных
логических операций, результатом выполнения которых
является логический тип данных, битовые логические операции
просто изменяют целое число согласно определенным
правилам. Точнее битовые операции изменяют отдельные биты
двоичного представления числа, в результате чего изменяется
его десятичное значение.
В языке программирования C существуют следующие
поразрядные операции: & (И), | (ИЛИ), ^ (исключающее ИЛИ),
<< (сдвиг влево), >> (сдвиг вправо), ~ (поразрядное дополнение
до единицы).
6710 = 0100 00112
11410 = 0111 00102
 Поразрядные операции и сдвиги
Обозначение Операция Пример
~ поразрядное отрицание ~ X
& поразрядное И X&Y
| поразрядное ИЛИ X | Y
^ поразрядное X ^Y
исключающее ИЛИ
<< поразрядный сдвиг X << 2
влево
>> поразрядный сдвиг Y >> 1
вправо
Поразрядные операции &, | и ^ работают
в соответствии со следующей таблицей,
где Е1 и Е2 — сравниваемые биты
операндов:
Е1 Е2 Е1 & Е2 Е1 ^ Е2 Е1 | Е2

1 0 0 1 1
0 0 0 0 0
0 1 0 1 1
1 1 1 0 1
Поразрядные логические операции
работают с целыми числами и
оперируют с их двоичными
представлениями, т.е. работают с
двоичными разрядами операндов.
При поразрядных операциях каждый бит
одного операнда комбинируется (в
зависимости от операции) с
одноименным битом другого, давая бит
результата. При единственной
одноместной поразрядной операции —
отрицании (~) — биты результата
являются инверсией соответствующих
битов ее операнда.
 cout << "\n 15 & 9 = " << (15 & 9) << endl;
cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl;
cout << "\n 15 | 9 = " << (15 | 9) << endl;
15 & 9 = 9 15=1111 00001111 00001111 00001111
15 ^ 9 = 6 9=1001 & 00001001 | 00001001 ^ 00001001
15 | 9 = 15 6=0110
00001001 00001111 00000110

17 &15 = 1
17 |15 = 31
17 ^15 =30
Т.к. 1710=100012 1510 =11112 , то дополняем 11112 нулем и согласно
предыдушей таблицы получаем 10001 &01111=00001=1
10001 | 01111=11111=31 15
10001 ^ 01111= 11110=30 30
14
31
17
При сдвиге влево биты первого операнда
перемещаются влево (в сторону старших
битов) на заданное вторым операндом
число позиций. Старшие биты,
оказавшиеся за пределами разрядной
сетки, теряются; справа результат
дополняется нулями.
Результат сдвига вправо зависит от того,
является ли операнд знаковым или без
знаковым. Биты операнда перемещаются
вправо на заданное число позиций.
Младшие биты теряются. Если операнд
— целое со знаком, производится
расширение знакового бита (старшего),
т. е. освободившиеся позиции
принимают значение 0 в случае
положительного числа и 1 — в случае
отрицательного. При без знаковом
операнде старшие биты заполняются
нулями.
Сдвиг влево на n эквивалентен
умножению на соответствующую степень
двойки, сдвиг вправо — делению на 2
степени n.
Например, в результате выполнения операции
сдвига 15>>2 получаем 3, т.к. 1510=11112 при сдвиге
разрядов на 2, младшие биты теряются и получаем
112 , а это 310.
58>>2 = 14 1110102/1002=11102= 1410
58<<2 = 232 1110102*1002=111010002= 23210

Исходное число 15 10 операция результат результат

00001111 <<3 01111000 12010

00001111 >>3 00000001 110
 Условная операция (?:)
Условная операция (?:) — единственная
трехчленная (тернарная) операция в C++,
имеющая три операнда. Ее синтаксис:
условие ? выражение_1 : выражение_2
Например,
cout<< grade > 3 ? "Вы хорошо знаете
материал" : "Плохо";
Выражение a>b?(ans=10):(ans=25); можно
упростить
ans=a>b?(10):(25); или ans=(а>b)?10:25;
 Maximum=(var1>var2)?var1:var2;
x=(a>0)? 1.5:2.3; или
if (a>0) x=1.5; else x=2.3;

Утверждение, если testvar<0, то sign=-1,

если testvar =0, то sign =0 иначе sign =+1
можно записать следующим образом:
sign=(testvar<0)? – 1: (testvar>0);
т.к. результат проверки testvar>0 будет 1
или 0.
Операция запятая (последование)
Операция запятая (,), называемая операцией
последования, соединяет два произвольных выражения,
которые вычисляются слева направо. Сначала
вычисляется выражение левого операнда. Тип его
результата считается void. Затем вычисляется выражение
правого операнда. Значение и тип результата операции
последования считается равным значению и типу правого
операнда.
Можно рекурсивно соединить операциями запятая
последовательность выражений:
выражение_1, выражение 2, ..., выражение n
Выражения будут вычисляться слева направо, а самое
правое выражение определит значение и тип всей этой
последовательности.
Например, фрагмент текста
а = 4;
b = а + 5;
можно записать как
а = 4, b = а + 5;
Соединяться запятыми могут не только выражения
присваивания, но и другие. Например, вызов функции с
тремя параметрами может иметь вид
func(i, (j = 1, j + 4), k);
Здесь в качестве второго параметра передается
значение операции последования, заключенной в
скобки. В результате вызов производится со
следующими аргументами: (i, 5, k).
Операция последования используется в основном в
операторах цикла for для задания в заголовке некоторой
совокупности действий. Например, цикл подсчета суммы
элементов некоторого массива можно осуществить циклом
for без использования операции последования:
int A[10], sum, i;
sum  A[0] ;
for (int i  1; i  10; i   ) sum   A [i] ;
To же самое можно реализовать более компактно с
помощью операции последования:
int A[10], sum, i;
for (i  1, sum  A[0]; i  10; sum   A[i], i   );
 Операция sizeof
Операция sizeof определяет размер в байтах своего операнда
— переменной, объекта, типа. Возвращаемый результат
имеет тип size_t (unsigned). Операция имеет две формы:
sizeof выражение
sizeof (имя типа)
Например:
sizeof *Labell;
sizeof(TLabel);
sizeof a;
sizeof (int);
Надо учесть, что размер переменной, объекта, типа может
изменяться в зависимости от машины и от используемой
версии программного обеспечения. Поэтому во всех случаях,
когда вам требуется знать размер объекта или типа, нельзя
полагаться на документацию, а надо использовать операцию
Если операндом является выражение, то sizeof
возвращает суммарный объем памяти, занимаемый
всеми переменными и константами, входящими в него.
Если операндом является массив, то возвращается
объем памяти, занимаемый всеми элементами
массива (т.е. имя массива не воспринимается в
данном случае как указатель). Число элементов в
массиве можно определить выражением
Если операндом является параметр, объявленный как
тип массива или функции, то возвращается размер
только указателя. К функциям операция sizeof не
применима.
Если операция sizeof применяется к структуре или
объединению, она возвращает общий объем памяти,
включая все наполнение этого объекта.
 Операция typeid
Операция typeid возвращает информацию
времени выполнения type_info, о типе или
выражении. Операция имеет две формы:
typeid( выражение )
typeid( тип )
Если операндом является разыменованный
указатель или ссылка на полиморфный тип,
операция typeid возвращает динамический тип
того реального объекта, на который ссылается
указатель или ссылка. Если оператор не
полиморфный, возвращается статический тип
объекта.
 В C++ определен ряд операций присваивания.
Обозна Операция Типы операндов и Пример
чение результата
= Присваивание Любые X=Y
+= присваивание со арифметические, X += Y
сложением указатели, структуры,
объединения (X=X + Y)
-= присваивание с арифметические, X -= Y
вычитанием указатели, структуры,
объединения (X=X – Y)
*= присваивание с арифметические X *= Y
умножением
(X=X * Y)
/= присвоение арифметические X /= Y
частного
(X=X / Y)
float c=3, a=4.5, b=2.3;
int i=4;
a + = 3;
b - = 2;
c = - c;
i %= 2;
i++; или i += 1; или i = i+1;
В C++ определен ряд операций присваивания.
Обозначе Операция Пример эквивалент
ние
%= присвоение остатка X %= Y Х= X % Y
<<= присвоение X <<= Y Х= X << Y
левого сдвига
>>= присвоение X >>= Y Х= X >> Y
правого сдвига
&= присвоение AND X &=Y Х= X & Y

^= присвоение XOR X ^= Y Х= X ^ Y

|= присвоение OR X |= Y Х= X | Y

, запятая
В операциях присваивания первый операнд не
может быть нулевым указателям.
Операции присваивания возвращают как
результат присвоенное значение. Благодаря
этому они допускают сцепление. Например, вы
можете написать: А = (В = С = 1) + 1;
Выполняются операции присваивания справа
налево. Поэтому приведенное выражение
задаст переменным В и С значения 1, а перемен-
ной А - 2. Вычисляться это будет следующим
образом. Сначала выполняются операции,
заключенные в скобки, а из них первой - самая
правая (т.е. С = 1). Эта операция вернет 1, так
что далее будет выполнена операция В = 1. Она
вернет значение 1, после чего выполнится опе-
рация сложения 1 + 1. Полученное в результате
значение 2 присвоится переменной А.
Приоритет и ассоциативность операций
Операция Ассоциативность

() [] -> :: слева направо

! ~ ++ — ++ -- & * sizeof new delete справа налево

.* — > * слева направо

*/% слева направо

+- слева направо

<< >> слева направо

< <= > >= слева направо

== != слева направо

& слева направо

^ слева направо

| слева направо

&& слева направо

|| справа налево

?: слева направо

= *= /= %= += -= &= ~= |= <<= >>= справа налево

, слева направо
Приоритет и ассоциативность операций
Прио Операция Ассоциати Описание
ритет вность
1 :: слева унарная операция разрешения области
направо действия
[] операция индексирования
() круглые скобки
. обращение к члену структуры или класса
-> обращение к члену структуры или класса
через указатель
2 ++ слева постфиксный инкремент
-- направо постфиксный декремент
3 + справа унарный плюс
- налево унарный минус
++ префиксный инкремент
-- префиксный декремент
! логическое НЕ (NOT)
~ побитовое НЕ (NOT)
& адрес
* разыменование
Прио Операция Ассоциатив Описание
ритет ность
4 * слева умножение
/ направо деление
% остаток от деления
5 + слева сложение
- направо вычитание
6 >> слева сдвиг вправо
<< направо сдвиг влево
7 < слева меньше
<= направо меньше либо равно
> больше
>= больше либо равно
8 == слева равно
!= направо не равно
9 & слева поразрядное И
^ направо поразрядное исключающее ИЛИ

| поразрядное ИЛИ
 Прио Операция Ассоциат Описание
ритет ивность
10 && слева логическое И
направо
11 || слева логическое ИЛИ
направо
12 ?: справа условная операция (тернарная
налево операция)
13 = справа присваивание
*= налево умножение с присваиванием
/= деление с присваиванием
%= остаток от деления с
присваиванием
+= сложение с присваиванием
-= вычитание с присваиванием
14 , слева запятая
направо