bulgakov

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. Полная программа выводит три миллиарда:

C
#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. Это полная программа:

C
#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 именно на том компьютере, где её собрали:

C
#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 может хранить факт готовности:

C
#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». Посмотрим на две переменные в одной программе:

C
#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 во время работы программы. Другой компилятор, процессор или уровень оптимизации могут дать иные адреса, регистры и набор инструкций при том же результате программы.

ПрактикаЗагружаем тест…