Для хранения данных в программе в языке C++ используются переменные. Фактически переменная представляет именнованный участок памяти. Переменная имеет тип, имя и значение. Тип определяет, какие именно данные может хранить переменная.
Перед использованием любую переменную надо определить. Синтаксис определения переменной выглядит следующим образом:
тип_переменной имя_переменной;
Имя переменной последовательность алфавитных-цифровых символов и знака подчеркивания _. При этом имя переменной должно начинаться с алфавитного символа или подчеркивания.
Кроме того, в качестве имени переменной нельзя использовать ключевые слова языке C++, например, for или if. Но таких слов не так много, и по ходу освоения C++ вы соориентируетесь, какие слова являются ключевыми.
Следует отметить, что при этом не рекомендуются следующие именования:
Дело в том, что при подобных именах повышается вероятность, что подобные названия будут конфликтовать с именами (например, именами переменных), которые генерирует компилятор или которые определены в подключаемых стандартных модулях C++. Поэтому некоторые вообще не рекомендуют начинать имя с символа подчеркивания
В общем случае переменная определяется в следующем виде:
тип_переменной имя_переменной;
Например, простейшее определение переменной:
int age;
Здесь определена переменная age, которая имеет тип int. Поскольку определение переменной представляет собой инструкцию, то после него ставится точка с запятой.
Также стоит учитывать, что C++ - регистрозависимый язык, а это значит, что регистр символов имеет большое значение. То есть в следующем коде будут определяться две разные переменные:
int age; int Age;
Поэтому переменная Age не будет представлять то же самое, что и переменная age.
Также нельзя объявить больше одной переменной с одним и тем же именем, например:
int age; int age;
Подобное определение вызовет ошибку на этапе компиляции.
После определения переменной можно присвоить некоторое значение. Присвоение переменной начального значения называется инициализацией. В C++ есть три вида инициализации:
Нотация присваивания (assignment notation)
Функциональная нотация (functional notation)
Инициализация в фигурных скобках (braced initialization)
Рассмотрим все эти виды инициализаций
Суть нотациия присваивания - с помощью оператора присваивания (знак "равно" или =) переменной передаем некоторое значение:
int age; age = 20;
Здесь в качестве значения переменной присваивается число 20. Постоянные значения любого типа, наподобие чисел, символов, строк, такие как 20, 123.456 (дробное число), "A" или "hello", называются литералами. То есть в данном случае переменной присваивается целочисленный литерал 20.
Например, определим в программе переменную и выведем ее значение на консоль:
#include <iostream>
int main()
{
int age;
age = 28;
std::cout<<"Age = " << age;
}
С помощью последовательности операторов << можно вывести несколько значений на консоль.
После компиляции и запуска скомпилированной программы на консоль будет выведено число 28.
Age = 28
Можно сразу при определении переменной дать ей некоторое начальное значение:
#include <iostream>
int main()
{
int age = 28;
std::cout<<"Age = " << age;
}
При инициализации braced initialization после названия переменной в фигурных скобках указывается ее значение:
int age {38}; // braced initialization
В данном случае переменная будет иметь значение 38.
При функциональной нотации после названия переменной в круглых скобках указывается ее значение:
int age (38); // functional notation
В данном случае переменная будет иметь значение 38.
Во всех трех случаях присваиваемое переменной значение может представлять сложное вычисляемое выражение. Например:
int age1 {22 + 5};
int age2 (22 + 5);
int age3 = 22 + 5;
Можно сразу инициализировать несколько переменных:
int age1 {22}, age2 (23), age3 = 24;
В большинстве случаев все три варианта инициализации эквивалентны. Однако инициализация в фигурных скобках немного безопаснее, когда применяется сужающее преобразование. В общем случае ожидается, что переменной передается значение, которое соответствует ее типу. Если же это не так, то компилятор попытается преобразовать присваиваемое значение в тип переменной. Сужающее преобразование изменяет значение одного типа на тип с более ограниченным диапазоном значений. Таким образом, преобразование может привести к потере информации. Возьмем следующий пример:
#include <iostream>
int main()
{
int age1 (23.5);
int age2 = 24.5;
std::cout<<"Age1 = " << age1 << "\n";
std::cout<<"Age2 = " << age2 << "\n";
}
Здесь переменным age1 и age2, которые представляют тип int, то есть целое число, присваивается дробное значение - 23.5 и 24.5 соответственно. Но в большинстве компиляторов, по крайней мере на момент написания данной статьи, этот код нормально скомпилируется и выполнится. Мы получим следующий вывод:
Age1 = 23 Age2 = 24
Теперь возьмем пример с инициализацией через фигурные скобки:
#include <iostream>
int main()
{
int age {22.5};
std::cout<<"Age = " << age << "\n";
}
Здесь переменной age, которая также представляет целое число, также присваивается дробное значение - 22.5. Однако теперь при компиляции многие компиляторы сообщат нам об ошибке. Например, вывод компилятора g++:
hello.cpp: In function 'int main()':
hello.cpp:5:15: error: narrowing conversion of '2.25e+1' from 'double' to 'int' [-Wnarrowing]
5 | int age1 {22.5};
Следует отметить, что некоторые компиляторы могут все таки скомпилировать данный код, однако все равно отобразят предупреждение.
При инициализации в фигурных скобках можно опустить значение:
int counter {};
В этом случае переменная будет инициализироваться нулем и фактически будет аналогично коду:
int counter {0};
Если переменную не инициализировать, то происходит ее инициализация по умолчанию. И переменная получает некоторое значение по умолчанию, которое зависит от места, где эта переменная определена.
Если переменная, которая представляет встроенный тип (например, тип int), определена внутри функции, то она получает неопределенное значение. Если переменная встроенного типа определена вне функции, то она получает то значение по умолчанию, которое соответствует ее типу. Для числовых типов это число 0. Например:
#include <iostream>
int x;
int main()
{
int y;
std::cout <<"X = " << x << "\n";
std::cout <<"Y = " << y;
}
Переменная x определена вне функции, и поэтому она получит значение по умолчанию - число 0.
Гораздо сложнее дело обстоит с переменной y, которая определена внутри функции main - ее значение будет неопределенным, и многое будет зависеть от используемого компилятора. В частности, вывод программы, скомпилированной с помощью компилятора G++, может выглядеть следующим образом:
X = 0 Y = 0
А в Visual Studio отсутствие значения переменной y вызовет ошибку компиляции.
Но в любом случае перед использованием переменной лучше явным образом назначать ей определенное значение, а не полагаться на значение по умолчанию.
Ключевой особенностью переменных является то, что мы можем изменять их значения:
#include <iostream>
int main()
{
int age = 22;
std::cout << "Age1 = " << age << "\n";
age = 23;
std::cout << "Age2 = " << age << "\n";
age = 38;
std::cout << "Age3 = " << age << "\n";
}
Консольный вывод программы:
Age1 = 22 Age2 = 23 Age3 = 38