Исполняемые доки C++: Типы данных

Q: Какие основные типы данных есть в C++?

Фундаментальные типы - это целые числа (short, int, long, long long), числа с плавающей точкой (float, double, long double), символьный тип char и логический тип bool. Каждый целочисленный тип также может быть signed или unsigned. Всё остальное - std::string, массивы, ваши собственные классы - строится поверх них.

Q: В чём разница между int и long в C++?

Оба хранят целые числа, но гарантируется, что long будет не уже, чем int (часто 64 бита на 64-битных платформах, но всего 32 бита в Windows). Стандарт фиксирует только минимальные размеры, поэтому для гарантированной разрядности используйте типы фиксированной ширины из , такие как int32t и int64t.

Q: Какого размера int в C++?

Стандарт гарантирует только, что int имеет не менее 16 бит, но практически на любом современном настольном компьютере и сервере это 32 бита. Поскольку размеры зависят от платформы, никогда не делайте предположений - выведите sizeof(int), чтобы проверить, или используйте типы из , такие как int32_t, когда нужна точная разрядность.

Почему типы важны в C++

На странице о переменных вы объявляли значения с явным типом, например int age = 30;. Этот тип - не просто ярлык: он сообщает компилятору, сколько байтов зарезервировать, как интерпретировать эти байты и какие операции допустимы. Ошибитесь с типом - и вы можете незаметно потерять точность, получить переполнение или вызвать неопределённое поведение.

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

Фундаментальные типы

Вот по одному примеру каждого основного типа в одной программе. Обратите внимание на суффиксы литералов (L, f, u) и одинарные кавычки у char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // целое число, обычно 32 бита
    long long big = 9000000000LL; // более широкое целое, суффикс LL
    double price = 19.99;       // 64-битное десятичное (по умолчанию для дробных)
    float  ratio = 0.5f;        // 32-битное десятичное - обратите внимание на f
    char   grade = 'A';         // один символ, одинарные кавычки
    bool   passed = true;       // только true или false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool печатается как 1 / 0
}

bool по умолчанию печатается как 1 или 0, а не true/false. char использует одинарные кавычки - 'A' это один символ, тогда как "A" (двойные кавычки) это строковый литерал, совершенно другой тип. Эти две ошибки крайне распространены на старте.

Размеры не фиксированы

Это самый большой сюрприз для тех, кто пришёл из языков вроде Java. Стандарт C++ гарантирует только минимальные размеры и относительный порядок (short ≤ int ≤ long ≤ long long). Фактический размер зависит от вашего компилятора и платформы. Всегда проверяйте через sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // всегда 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

В типичной 64-битной сборке для Linux вы увидите int = 4, long = 8. Однако в 64-битной Windows long занимает всего 4 байта. Именно этот разрыв в переносимости и есть причина, по которой не стоит писать код, предполагающий, что long 64-битный.

Когда нужна точная разрядность, обратитесь к целочисленным типам фиксированной ширины из <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // ровно 8 бит, signed
    uint16_t b = 65000;         // ровно 16 бит, unsigned
    int32_t  c = 2000000000;    // ровно 32 бита
    int64_t  d = 9000000000LL;  // ровно 64 бита, на любой платформе

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

Используйте int32_t/int64_t для форматов файлов, сетевых протоколов или всего, что должно вести себя одинаково на разных машинах. Обратите внимание на приведение (int)a - вывод 8-битного типа в поток печатает его как символ, а не как число, поэтому сначала выполните приведение.

Signed и unsigned

Каждый целочисленный тип бывает двух разновидностей. Тип signed может хранить отрицательные значения; тип unsigned не может, обменивая отрицательный диапазон на больший положительный максимум. Обычный int по умолчанию signed.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // НЕ становится -1
    cout << u << "\n";  // оборачивается до 4294967295 (максимум unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

Вычитание из беззнакового 0 оборачивается в огромное положительное число вместо того, чтобы стать отрицательным. На этом люди попадаются постоянно - особенно с size_t (беззнаковый тип), возвращаемым .size():

vector<int> v = {1, 2, 3};
// ОПАСНО: v.size() беззнаковый. Если v пуст, v.size() - 1 оборачивается
// в гигантское число, и цикл выполняется почти бесконечно.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

Предпочитайте i < v.size() (никогда <= size() - 1) или обойдите проблему целиком с помощью цикла for по диапазону.

Переполнение целых чисел - это неопределённое поведение

В отличие от оборачивания беззнаковых (которое чётко определено), переполнение знакового целого числа в C++ является неопределённым поведением. Компилятору разрешено делать что угодно - вернуть мусор, выкинуть проверку при оптимизации или аварийно завершиться:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // НЕОПРЕДЕЛЁННОЕ ПОВЕДЕНИЕ - часто оборачивается в отрицательное

    long long safe = (long long)maxInt + 1; // повысить тип перед сложением
    cout << safe << "\n";            // 2147483648, правильно
}

Решение такое же, как и ловушка переполнения в любом языке: выполняйте арифметику в более широком типе. Приведите один операнд к long long перед +, чтобы сложение происходило в 64 битах. Приводить результат после уже поздно - переполнение уже случилось.

Выбор правильного типа

Для большей части кода значения по умолчанию подходят: int для целых чисел, double для дробных. Обращайтесь к чему-то ещё только тогда, когда на это есть причина.

Тип	Типичный размер	Использовать, когда
`int`	32 бита	По умолчанию для целых чисел
`long long`	64 бита	Значения свыше ~2 млрд: метки времени, большие счётчики
`double`	64 бита	По умолчанию для дробных - хорошая точность
`float`	32 бита	Массивы с ограниченной памятью, где точностью можно пожертвовать
`bool`	1 байт	Флаг true/false
`int32_t` / `int64_t`	точный	Кроссплатформенные форматы, протоколы, работа с битами

Пара подводных камней, о которых стоит помнить. У float всего около 7 значащих десятичных цифр, поэтому 0.1f + 0.2f не равно в точности 0.3 - предпочитайте double, если только вам действительно не нужно экономить память. А char может быть signed или unsigned в зависимости от платформы, поэтому, если вы делаете арифметику над сырыми байтами, явно указывайте signed char или unsigned char.

Далее: Ключевое слово auto

Выписывать тип каждый раз утомительно, а иногда тип длинный или его трудно назвать. C++ позволяет компилятору вывести его за вас с помощью ключевого слова auto - auto x = 42; делает x типом int, а auto it = v.begin(); избавляет от набора многословного типа итератора. Следующая страница рассказывает, когда auto делает код яснее, а когда скрывает слишком многое.

Часто задаваемые вопросы

Какие основные типы данных есть в C++?

Фундаментальные типы - это целые числа (short, int, long, long long), числа с плавающей точкой (float, double, long double), символьный тип char и логический тип bool. Каждый целочисленный тип также может быть signed или unsigned. Всё остальное - std::string, массивы, ваши собственные классы - строится поверх них.

В чём разница между int и long в C++?

Оба хранят целые числа, но гарантируется, что long будет не уже, чем int (часто 64 бита на 64-битных платформах, но всего 32 бита в Windows). Стандарт фиксирует только минимальные размеры, поэтому для гарантированной разрядности используйте типы фиксированной ширины из <cstdint>, такие как int32_t и int64_t.

Какого размера int в C++?

Стандарт гарантирует только, что int имеет не менее 16 бит, но практически на любом современном настольном компьютере и сервере это 32 бита. Поскольку размеры зависят от платформы, никогда не делайте предположений - выведите sizeof(int), чтобы проверить, или используйте типы из <cstdint>, такие как int32_t, когда нужна точная разрядность.

Связанные концепции

Типы данных в C++: int, double, char, bool и другие