08. Типы: какие значения можно хранить
Тип нужен не только для записи переменной. Он определяет какие значения можно сохранить и по каким правилам участвовать в вычислениях. Поэтому 8 / 3 и 8.0 / 3 дают разные результаты.
Для небольшого целого количества подходит int, для дробной величины — double, для одного символа базовой кодировки — char. Не нужно выбирать тип по длине числа на экране: printf может показать одно значение разными способами.
Бит — один двоичный разряд, 0 или 1. В обычном компьютере байт состоит из восьми битов.
Целые со знаком и без знака
Обычный int хранит и отрицательные, и неотрицательные значения. Тип unsigned int хранит только неотрицательные — включая ноль. У каждого типа есть нижняя и верхняя границы.
На распространённой платформе с 32-битным int в дополнительном коде:
| Тип | Диапазон |
|---|---|
int |
От −2 147 483 648 до 2 147 483 647 |
unsigned int |
От 0 до 4 294 967 295 |
У беззнакового варианта те же биты используются без отрицательной половины диапазона. Верхняя граница на единицу меньше числа возможных значений, потому что отсчёт начинается с нуля. Однако unsigned не является проверкой ввода: запись отрицательного числа в такой тип не запрещает действие автоматически, а приводит к преобразованию значения.
Если целые результаты велики, есть тип long long. Полная программа выводит три миллиарда:
#include <stdio.h>
int main(void)
{
long long population = 3000000000LL;
printf("Population: %lld\n", population);
return 0;
}
Вывод — Population: 3000000000. Суффикс LL задаёт тип записанного числа long long, а %lld — формат его вывода. Тип переменной, тип числа в исходнике и формат вывода связаны, но это разные записи.
У целых типов есть семейство вариантов. Эта таблица нужна, чтобы узнавать их в коде:
| Тип | Для чего различать |
|---|---|
short, int, long, long long |
Целые типы с разными гарантированными диапазонами; каждый следующий вмещает не меньше предыдущего |
unsigned int, unsigned long и другие unsigned |
Беззнаковые варианты целых типов |
signed char, unsigned char |
Явно знаковый и беззнаковый целый тип размером в один байт |
char |
Отдельный тип для символов; его знаковость зависит от реализации |
Слово signed означает «со знаком»: например, signed int и int обозначают один тип. Для long выводят через %ld, для unsigned int — через %u, для long long — через %lld. При чтении long long у scanf тоже %lld, с адресом переменной.
Слово int в некоторых именах можно опустить: short и short int — один тип, как и long с long int, long long с long long int. Это разные способы записи, а не дополнительные размеры целых чисел.
Размер и диапазон — не одно и то же
Размер переменной — сколько байтов занимает её представление. Диапазон — какие значения она может хранить.
Восемь бит дают 256 различных комбинаций. Их можно использовать для целых от 0 до 255 или договориться представлять и отрицательные числа. Поэтому одного размера недостаточно, чтобы узнать смысл данных: нужен ещё тип.
Узнать размер типа в C позволяет оператор sizeof. Это полная программа:
#include <stdio.h>
int main(void)
{
printf("char: %zu\n", sizeof(char));
printf("int: %zu\n", sizeof(int));
printf("double: %zu\n", sizeof(double));
return 0;
}
На многих современных компьютерах вывод будет таким:
char: 1
int: 4
double: 8
Здесь sizeof(int) даёт количество байтов, не битов. Результат sizeof имеет целый тип size_t, для которого в printf предусмотрен формат %zu.
Размеры определяются реализацией C: например, long бывает размером 4 или 8 байт. Для char размер в байтах всегда 1; количество битов в байте задаёт CHAR_BIT из <limits.h> и оно не обязано быть ровно 8 на любой возможной машине.
Границы своего int можно получить из того же <limits.h>: INT_MIN — минимум, INT_MAX — максимум. Стандарт C17 гарантирует для int хотя бы диапазон от −32 767 до 32 767; приведённый выше 32-битный диапазон — распространённый, но не универсальный.
Если нужен диапазон другого целого типа, <limits.h> даёт пары SHRT_MIN/SHRT_MAX, LONG_MIN/LONG_MAX, LLONG_MIN/LLONG_MAX. У беззнакового unsigned int нижняя граница — 0, верхняя — UINT_MAX. Например, эта программа показывает границы long именно на том компьютере, где её собрали:
#include <limits.h>
#include <stdio.h>
int main(void)
{
printf("long: %ld .. %ld\n", LONG_MIN, LONG_MAX);
return 0;
}
На распространённой системе с 64-битным long в дополнительном коде вывод будет long: -9223372036854775808 .. 9223372036854775807; на другой системе числа могут отличаться. Макросы LONG_MIN и LONG_MAX дают границы, а %ld показывает значения типа long десятичными цифрами.
bool: сохранить «да» или «нет»
Для значения с двумя состояниями в C17 есть bool из <stdbool.h>. Например, переменная ready может хранить факт готовности:
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
bool ready = true;
bool empty = false;
printf("Ready: %d; empty: %d\n", ready, empty);
return 0;
}
Вывод — Ready: 1; empty: 0. true обозначает истину, false — ложь, а числовой вывод показывает их как 1 и 0. При преобразовании в bool ноль становится ложью, любое ненулевое число — истиной.
Выбирая тип, учитывайте и промежуточные результаты: два небольших числа могут дать большое произведение. Само наличие подходящей переменной для ответа ещё не гарантирует, что вычисление выполнится в её типе.
Почему четыре байта не сообщают процессору тип
Когда вы пишете тип в исходнике, компилятор выбирает операции для этого типа. На многих компьютерах и int, и float занимают по четыре байта. Но в самих байтах нет подписи «это int» или «это float». Посмотрим на две переменные в одной программе:
#include <stdio.h>
int main(void)
{
int a = 1;
float f = 1.0f;
a = a + 1;
f = f + 1;
printf("a = %d, f = %.1f\n", a, f);
return 0;
}
Вывод — a = 2, f = 2.0. В первой операции получается целое 2 и записывается в a. Во второй целое 1 преобразуется для сложения с float; результат 2.0 записывается в f. Это преобразование сохраняет числовой смысл единицы: оно не заставляет прочитать биты целого 1 как готовое дробное число. Формат %.1f показывает одну цифру после точки, но не меняет сохранённое значение. Для float в printf подходит %f: при передаче в эту функцию значение автоматически преобразуется в double. Формат %u предназначен для unsigned int; использовать его с f нельзя — поведение программы не определено.
В одной конкретной сборке x86-64 GCC без оптимизации можно увидеть такие ассемблерные фрагменты:
| Действие в C | Ассемблерный фрагмент | Смысл |
|---|---|---|
a = a + 1 |
add DWORD PTR [rbp-4], 1 |
Сложить целые числа; операнд в памяти занимает четыре байта |
f = f + 1 |
movss → addss → movss |
Загрузить значение, сложить числа формата float, сохранить результат |
В строке movss xmm1, DWORD PTR [rbp-8] из такой сборки DWORD PTR тоже означает память шириной четыре байта, а не тип переменной в C. Инструкция add задаёт целочисленное сложение; addss — сложение чисел с плавающей точкой. Процессор выполняет выбранную инструкцию и обрабатывает биты по её правилам. Ему не нужна отдельная запись объявления int a или float f во время работы программы. Другой компилятор, процессор или уровень оптимизации могут дать иные адреса, регистры и набор инструкций при том же результате программы.
