Типы данных и константы

Типы данных и константы в C++

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

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

1int health = 100;2double speed = 4.5;3bool isAlive = true;

Помимо обычных переменных, в C++ существуют константы — значения, которые нельзя изменять после инициализации. Они помогают защитить данные от случайных изменений и делают назначение кода понятнее.

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

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

• Целочисленные — хранят целые числа.
• С плавающей точкой — хранят приближённые значения с дробной частью.
• Символьные — предназначены для хранения символов и кодовых единиц.
• Логические — представляют истину или ложь.
• Составные и пользовательские — позволяют объединять данные или создавать собственные типы.

Целочисленные типы

Целочисленные типы используются для хранения значений без дробной части. Они различаются диапазоном представимых значений.

Точный размер типов зависит от реализации компилятора и платформы. Для проверки размера в байтах можно использовать оператор sizeof.

 1#include <iostream> 2 3int main() { 4    std::cout << sizeof(short) << '\n'; 5    std::cout << sizeof(int) << '\n'; 6    std::cout << sizeof(long) << '\n'; 7    std::cout << sizeof(long long) << '\n'; 8 9    return 0;10}

Результат будет зависеть от используемой платформы и компилятора.

Знаковые и беззнаковые числа

Знаковые целочисленные типы, например int, могут хранить отрицательные и положительные значения. Беззнаковые типы, например unsigned int, предназначены для неотрицательных значений.

1int temperature = -15;2unsigned int playerCount = 20;

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

1unsigned int count = 0;2count--;34std::cout << count << '\n';

В этом примере значение станет максимальным представимым значением типа unsigned int, а не -1.

Не стоит использовать unsigned только ради запрета отрицательных значений: смешивание знаковых и беззнаковых чисел может приводить к неожиданным результатам сравнений и вычислений.

Типы с плавающей точкой

Для хранения дробных чисел в C++ используются float, double и long double.

Пример:

1float playerSpeed = 4.5f;2double distance = 125.75;3long double preciseValue = 3.141592653589793L;

Суффикс f обозначает литерал типа float, а L — литерал типа long double.

Почему дробные числа могут быть неточными

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

1#include <iostream>23int main() {4    double value = 0.1 + 0.2;56    std::cout << value << '\n';78    return 0;9}

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

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

Логический тип bool

Тип bool имеет только два значения:

• true — истина;
• false — ложь.

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

1bool isConnected = true;2bool isPaused = false;34if (isConnected) {5    // Выполняется, если соединение установлено.6}

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

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

Вывод:

1true

Символьные типы

В C++ есть несколько типов для хранения символов и кодовых единиц:

• char — базовый символьный тип, также используемый для представления отдельных байтов;
• wchar_t — тип для широких символов, размер и применение которого зависят от реализации;
• char8_t — тип для кодовых единиц UTF-8;
• char16_t — тип для кодовых единиц UTF-16;
• char32_t — тип для кодовых единиц UTF-32.

Для обычных символьных литералов часто используется char.

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

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

1char letter = 'A';2const char* text = "Hello";

Типы char8_t, char16_t и char32_t полезны при работе с соответствующими форматами кодирования. При этом один символ Unicode может занимать несколько кодовых единиц, например в UTF-8.

Строки

Для работы с текстом в стандартной библиотеке C++ обычно используется std::string.

 1#include <iostream> 2#include <string> 3 4int main() { 5    std::string username = "Alex"; 6 7    std::cout << "Привет, " << username << "!\n"; 8 9    return 0;10}

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

Строку можно изменять после создания:

1std::string message = "Hello";2message += ", world!";

После выполнения этих строк переменная message содержит Hello, world!.

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

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

1auto age = 18;       // int2auto speed = 4.5;    // double3auto isActive = true; // bool

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

При использовании auto тип всё равно определяется на этапе компиляции — это не динамическая типизация.

1auto count = 10;2count = 20;     // Допустимо3// count = 3.14; // Для int дробная часть потеряется при преобразовании

Если переменная уже имеет тип int, присваивание ей другого числового типа не меняет тип самой переменной.

Преобразование типов

Иногда необходимо преобразовать значение из одного типа в другой.

Неявное преобразование

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

1int value = 10;2double result = value;

Здесь целое число преобразуется в double. В данном случае значение 10 представляется точно.

При обратном преобразовании возможна потеря информации:

1double value = 9.8;2int result = value;34std::cout << result << '\n';

Результат:

19

При преобразовании такого значения в int дробная часть отбрасывается.

Явное преобразование

Чтобы явно указать преобразование, можно использовать static_cast.

1double value = 9.8;2int result = static_cast<int>(value);

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

Что такое константа

Константа — это значение, которое после инициализации нельзя изменить через соответствующий объект или объявление.

В C++ для этого часто используются const и constexpr.

Константы с const

Ключевое слово const запрещает изменять объект через имя, объявленное с этим квалификатором.

1const int maxHealth = 100;2const double gravity = 9.81;

Попытка присвоить новое значение такой переменной приведёт к ошибке компиляции:

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

Константа должна получить значение при инициализации. Это полезно для настроек, фиксированных параметров и значений, которые не должны случайно меняться.

Константные выражения с constexpr

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

1constexpr int windowWidth = 1280;2constexpr int windowHeight = 720;3constexpr int pixelCount = windowWidth * windowHeight;

Поскольку значения известны во время компиляции, компилятор может вычислить pixelCount заранее.

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

 1int getValue() { 2    return 10; 3} 4 5int main() { 6    const int runtimeValue = getValue(); 7    constexpr int compileTimeValue = 10; 8 9    return 0;10}

В этом примере runtimeValue является константой, но её значение определяется при выполнении программы. compileTimeValue — константное выражение, известное при компиляции.

Разница между const и constexpr

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

Константы и указатели

При работе с указателями важно различать константный объект и константный указатель.

1int value = 10;2int otherValue = 20;34const int* ptr = &value;5ptr = &otherValue; // Можно изменить адрес6// *ptr = 30;      // Нельзя изменить значение через ptr

const int* — указатель на константный int: через него нельзя изменять объект, но сам указатель можно перенаправить на другой объект подходящего типа.

1int value = 10;2int* const ptr = &value;34*ptr = 30; // Можно изменить значение5// ptr = nullptr; // Нельзя изменить сам указатель

int* const — константный указатель на изменяемый int. Его адрес нельзя изменить после инициализации, но объект можно изменять через указатель.

1const int* const ptr = &value;

В этом случае нельзя изменить ни адрес указателя, ни значение объекта через этот указатель.

Пользовательские типы данных

C++ позволяет создавать собственные типы, объединяя данные или задавая новые правила их представления.

Например, struct позволяет объединить связанные значения:

 1struct Player { 2    int health; 3    double speed; 4}; 5 6int main() { 7    Player player{100, 4.5}; 8 9    return 0;10}

Здесь Player — пользовательский тип, содержащий здоровье и скорость игрока. Переменная player хранит объект этого типа.

Также можно создавать перечисления с помощью enum class:

1enum class GameState {2    Menu,3    Playing,4    Paused,5    GameOver6};78GameState state = GameState::Playing;

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

Пример: типы данных и константы вместе

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

 1#include <iostream> 2#include <string> 3 4int main() { 5    const std::string playerName = "Alex"; 6    constexpr int maxHealth = 100; 7 8    int health = maxHealth; 9    double speed = 4.5;10    bool isAlive = true;1112    health -= 25;13    isAlive = health > 0;1415    std::cout << "Игрок: " << playerName << '\n';16    std::cout << "Здоровье: " << health << '/' << maxHealth << '\n';17    std::cout << "Скорость: " << speed << '\n';18    std::cout << "Жив: " << std::boolalpha << isAlive << '\n';1920    return 0;21}

Вывод:

1Игрок: Alex2Здоровье: 75/1003Скорость: 4.54Жив: true

maxHealth — константа времени компиляции, а playerName — строка, которую программа не должна изменять. Значения health, speed и isAlive могут изменяться во время выполнения программы.

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

Выход за диапазон типа

1int value = 2147483647;2value++;

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

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

1int result = static_cast<int>(5.9);

Значение result будет равно 5. Если дробная часть важна, используй подходящий тип, например double.

Попытка изменить константу

1const int maxPlayers = 10;2// maxPlayers = 20; // Ошибка компиляции

Если значение должно меняться, не объявляй его как const.

Использование constexpr для значения времени выполнения

1int readValue();23int main() {4    // constexpr int value = readValue(); // Ошибка, если результат не является константным выражением56    return 0;7}

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

Итог

• Тип данных определяет представление значения и допустимые операции.
• int, float, double, bool, char и std::string решают разные задачи хранения.
• Размеры некоторых встроенных типов зависят от платформы и реализации компилятора.
• auto позволяет компилятору вывести тип из инициализатора.
• Преобразование типов может приводить к потере данных, поэтому важно учитывать его последствия.
• const запрещает изменение объекта через соответствующее объявление.
• constexpr используется для значений, которые должны быть константными выражениями.
• struct и enum class помогают создавать собственные типы для организации данных.