Переменные

Переменные в C++

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

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

Что такое переменная

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

1int age = 18;

В этом примере:

• int — тип данных, определяющий, что переменная хранит целое число.
• age — имя переменной.
• 18 — начальное значение.

Теперь программа может обращаться к переменной age, чтобы получить или изменить сохранённое значение.

1#include <iostream>23int main() {4    int age = 18;56    std::cout << age << '\n';78    return 0;9}

Вывод:

118

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

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

1int score;        // Объявление без начального значения2int health = 100; // Объявление с начальным значением

В первом случае переменная score объявлена, но её значение не задано. Для локальной переменной встроенного типа это означает, что её нельзя безопасно читать до присваивания значения.

Во втором случае health сразу получает значение 100.

Можно также объявить несколько переменных одного типа:

1int x = 10;2int y = 20;3int z = 30;

Или записать несколько объявлений в одной строке:

1int x = 10, y = 20, z = 30;

Для начинающих отдельные объявления обычно удобнее: так проще читать код и изменять его.

Основные типы данных

В C++ тип переменной определяет, какие значения она может хранить и какие операции с ней доступны.

Целые числа — int

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

1int age = 25;2int score = 1500;3int temperature = -10;

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

Дробные числа — float и double

Эти типы позволяют хранить числа с дробной частью.

1float speed = 4.5f;2double distance = 125.75;

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

Обрати внимание на суффикс f в записи 4.5f: он указывает, что литерал имеет тип float.

Символы — char

Тип char предназначен для хранения одного символа из базового набора символов исполнения.

1char grade = 'A';2char operation = '+';

Символ записывается в одинарных кавычках. Запись 'A' отличается от "A", которая представляет строковый литерал.

Логические значения — bool

Переменная типа bool может принимать только два значения: true и false.

1bool isAlive = true;2bool isPaused = false;

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

1int health = 0;2bool isAlive = health > 0;34std::cout << isAlive << '\n';

При стандартных настройках потока программа выведет 0, поскольку выражение health > 0 ложно.

Строки — std::string

Для хранения текста в стандартной библиотеке C++ существует тип std::string.

1#include <string>23std::string name = "Alex";4std::string message = "Привет, мир!";

Чтобы использовать std::string, необходимо подключить заголовок <string>.

Изменение значения переменной

После объявления переменной её значение можно менять с помощью оператора присваивания =.

1int score = 100;23score = 250;

После второй строки переменная score содержит 250, а не 100.

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

1int coins = 10;23coins += 5;  // coins = coins + 54coins -= 3;  // coins = coins - 35coins *= 2;  // coins = coins * 26coins /= 4;  // coins = coins / 4

В результате переменная coins будет содержать 6.

Если переменная имеет целочисленный тип, деление двух целых чисел отбрасывает дробную часть:

1int result = 7 / 2;23std::cout << result << '\n';

Вывод:

13

Чтобы получить дробный результат, хотя бы один из операндов должен иметь дробный тип:

1double result = 7.0 / 2;23std::cout << result << '\n';

Вывод:

13.5

Инициализация и присваивание

Инициализация — это задание начального значения при создании переменной. Присваивание — изменение значения уже существующей переменной.

1int health = 100; // Инициализация2health = 75;      // Присваивание

В C++ также доступны другие формы инициализации:

1int a = 10;2int b(20);3int c{30};

Форма с фигурными скобками c{30} особенно полезна тем, что запрещает некоторые небезопасные преобразования типов.

Например, следующий код не скомпилируется:

1int value{3.14};

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

Константные переменные

Иногда значение должно оставаться неизменным после создания переменной. Для этого используется ключевое слово const.

1const int maxHealth = 100;2const double pi = 3.14159;

После инициализации изменить такую переменную нельзя:

1const int maxHealth = 100;23maxHealth = 200; // Ошибка компиляции

const помогает защитить данные от случайных изменений и показывает назначение значения в коде.

Если значение известно во время компиляции и подходит для вычисления на этапе компиляции, можно использовать constexpr:

1constexpr int windowWidth = 1280;2constexpr int windowHeight = 720;

constexpr применяется для значений, которые должны быть константными выражениями.

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

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

Допустимые примеры:

1int playerHealth = 100;2int enemy_count = 5;3double movementSpeed = 3.5;4bool isGameRunning = true;

Основные правила:

• Имя может содержать латинские буквы, цифры и символ подчёркивания _.
• Имя не может начинаться с цифры.
• Пробелы в имени не допускаются.
• Регистр имеет значение: score и Score — разные имена.
• Ключевые слова C++ нельзя использовать в качестве имён переменных.
• Лучше выбирать имена, которые объясняют назначение значения.

Например, вместо короткого и неочевидного имени x в подходящем контексте лучше использовать playerPositionX.

Плохой пример:

1int a = 100;2int b = 5;3int c = a - b;

Более понятный вариант:

1int playerHealth = 100;2int damage = 5;3int remainingHealth = playerHealth - damage;

Второй вариант легче читать и поддерживать.

Автоматическое определение типа с auto

Ключевое слово auto позволяет компилятору определить тип переменной по начальному значению.

1auto age = 18;       // int2auto speed = 4.5;    // double3auto name = "Alex";  // const char*

Тип определяется по правилам вывода типов C++. Например, литерал 4.5 имеет тип double, а строковый литерал "Alex" в данном случае не создаёт объект std::string.

Если требуется именно строка std::string, можно написать:

1#include <string>23auto name = std::string{"Alex"};

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

Область видимости переменных

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

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

 1#include <iostream> 2 3int main() { 4    int score = 100; 5 6    { 7        int bonus = 50; 8        score += bonus; 9    }1011    std::cout << score << '\n';1213    return 0;14}

Вывод:

1150

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

1int main() {2    {3        int bonus = 50;4    }56    // std::cout << bonus; // Ошибка: bonus вне области видимости78    return 0;9}

Пример: использование переменных в программе

Объединим несколько типов данных в небольшой программе:

 1#include <iostream> 2#include <string> 3 4int main() { 5    std::string playerName = "Alex"; 6    int health = 100; 7    int damage = 25; 8    bool isAlive = true; 910    health -= damage;11    isAlive = health > 0;1213    std::cout << "Игрок: " << playerName << '\n';14    std::cout << "Здоровье: " << health << '\n';15    std::cout << "Жив: " << isAlive << '\n';1617    return 0;18}

Результат выполнения:

1Игрок: Alex2Здоровье: 753Жив: 1

Здесь playerName хранит имя игрока, health — его здоровье, damage — величину урона, а isAlive — результат проверки, осталось ли у игрока здоровье.

По умолчанию std::cout выводит логическое значение true как 1, а false как 0. Чтобы выводить слова true и false, можно использовать std::boolalpha.

Частые ошибки

Использование неинициализированной переменной

1int score;2std::cout << score; // Ошибка логики: значение не задано

Для локальной переменной int чтение до инициализации приводит к неопределённому поведению.

Правильный вариант:

1int score = 0;2std::cout << score;

Несовместимые типы данных

1int age = "18"; // Ошибка компиляции

Строковый литерал нельзя напрямую присвоить переменной типа int.

Правильный вариант:

1int age = 18;

Потеря дробной части

1int price = 19.99;

Такое преобразование отбрасывает дробную часть значения. Если требуется хранить дробные числа, используй double:

1double price = 19.99;

Повторное объявление переменной в одной области видимости

1int score = 10;2int score = 20; // Ошибка

В одной области видимости нельзя повторно объявить локальную переменную с тем же именем.

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

1int score = 10;2score = 20;

Итог

• Переменные хранят данные, которые используются программой.
• При объявлении указываются тип и имя переменной.
• Тип данных определяет, какие значения можно хранить.
• Оператор = используется для инициализации и присваивания.
• const защищает значение от изменения, а constexpr позволяет задавать константы времени компиляции.
• auto помогает компилятору определить тип по начальному значению.
• Область видимости определяет, где переменная доступна.
• Понятные имена инициализированные значения делают код безопаснее и проще для чтения.