Раздел 3 — Типы данных и память

Оперативная память — длинный ряд байтов. Байт — 8 бит, каждый бит — 0 или 1, поэтому в байте 2⁸ = 256 разных значений. У каждого байта есть номер — адрес. Всё, что хранит программа — числа, текст, картинки, — записано в памяти байтами.

Переменная — именованное место в памяти. У неё четыре характеристики:

int count = 25;

  имя       count
  тип       int — 4 байта, целое со знаком
  адрес     номер первого из 4 байтов, выбирается при запуске (раздел 10)
  значение  25, записано в этих 4 байтах в двоичном виде

Тип определяет, сколько байт занимает значение, какие значения в них помещаются и какие операции с ними можно делать. Одни и те же 4 байта 00 00 C0 3F — это целое 1 069 547 520, если тип int, и вещественное 1.5, если тип float: память не знает, что в ней лежит, это знает только тип переменной.

Переменную нужно объявить до использования. Объявление без начального значения оставляет в памяти то, что там было раньше — «мусор»:

int total;              /* значение не определено */
int sum = 0;            /* значение 0 */
int a = 1, b = 2;       /* две переменные в одной строке — так можно, но лучше по одной */

Стандарт C не задаёт точных размеров целых типов — только минимальные. Фактический размер зависит от компилятора и ОС и узнаётся операцией sizeof:

/* Размеры типов в байтах */
#include <stdio.h>

int main(void)
{
    printf("char      %zu\n", sizeof(char));
    printf("short     %zu\n", sizeof(short));
    printf("int       %zu\n", sizeof(int));
    printf("long      %zu\n", sizeof(long));
    printf("long long %zu\n", sizeof(long long));
    printf("float     %zu\n", sizeof(float));
    printf("double    %zu\n", sizeof(double));
    return 0;
}

%zu — формат для результата sizeof (тип size_t, беззнаковое целое).

Ловушка — long: в Windows он 4 байта, в Linux 8. Программа, где в long хранятся числа больше двух миллиардов, работает в Linux и ломается в Windows. Поэтому в курсе long не используется: нужно больше int — берите long long.

Когда размер важен точно (формат файла, сетевой протокол), используют типы из <stdint.h> — у них размер в имени: int8_t, int16_t, int32_t, int64_t и беззнаковые uint8_t … uint64_t. Границы типов — константы из <limits.h>:

/* Границы целых типов */
#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("INT_MIN   = %d\n", INT_MIN);
    printf("INT_MAX   = %d\n", INT_MAX);
    printf("UINT_MAX  = %u\n", UINT_MAX);
    printf("LLONG_MAX = %lld\n", LLONG_MAX);
    return 0;
}

INT_MIN   = -2147483648
INT_MAX   = 2147483647
UINT_MAX  = 4294967295
LLONG_MAX = 9223372036854775807

%u — беззнаковое целое, %lld — long long. Формат должен совпадать с типом значения: gcc с -Wall проверяет это и предупреждает о несовпадении (раздел 1, пункт 07).

У каждого целого типа есть беззнаковая версия: unsigned int, unsigned long long и т. д. Отрицательных значений у неё нет, а наибольшее вдвое больше: unsigned int — от 0 до 4 294 967 295.

Отрицательные числа хранятся в дополнительном коде. Для 8 бит: 0 — 00000000, 1 — 00000001, 127 — 01111111; −1 — 11111111, −128 — 10000000. Старший бит — признак знака. Одни и те же 8 бит 11111111 — это −1 в int8_t и 255 в uint8_t.

Переполнение — результат не помещается в тип. Для беззнаковых стандарт определяет результат: значение «заворачивается» по кругу, берётся остаток от деления на 2^N, где N — число бит:

/* Переполнение беззнакового типа — по кругу */
#include <stdio.h>
#include <limits.h>

int main(void)
{
    unsigned int u = 0;
    u = u - 1;
    printf("0 - 1   = %u\n", u);

    unsigned int m = UINT_MAX;
    m = m + 1;
    printf("MAX + 1 = %u\n", m);
    return 0;
}

0 - 1   = 4294967295
MAX + 1 = 0

Для знаковых типов переполнение — неопределённое поведение (undefined behavior, UB): стандарт не говорит, что произойдёт. На практике чаще всего получается заворот (INT_MAX + 1 → INT_MIN), но компилятор при оптимизации вправе считать, что переполнения не бывает, и выбросить проверки, которые на него рассчитывают. Программа с UB может работать при отладке и ломаться в релизной сборке.

Вещественные числа хранятся в форме с плавающей точкой (стандарт IEEE 754): знак, порядок и мантисса — как 1,5 · 10³, только по основанию 2.

Главное свойство: большинство десятичных дробей хранится неточно. 0,1 в двоичной записи — бесконечная периодическая дробь 0,000110011001100…, как 1/3 в десятичной. В double хранится ближайшее представимое число:

/* Погрешность double */
#include <stdio.h>
#include <math.h>

int main(void)
{
    double a = 0.1 + 0.2;
    printf("0.1 + 0.2 = %.17g\n", a);
    printf("0.3       = %.17g\n", 0.3);
    printf("a == 0.3        : %d\n", a == 0.3);
    printf("|a - 0.3| < 1e-9: %d\n", fabs(a - 0.3) < 1e-9);

    float f = 16777217.0f;
    printf("float 16777217 = %.1f\n", f);
    return 0;
}

0.1 + 0.2 = 0.30000000000000004
0.3       = 0.29999999999999999
a == 0.3        : 0
|a - 0.3| < 1e-9: 1
float 16777217 = 16777216.0

• %.17g — вывести 17 значащих цифр: так видна погрешность, которую обычный %f (6 знаков после точки) скрывает округлением.
• Сравнение даёт 1 (истина) или 0 (ложь). 0.1 + 0.2 == 0.3 — ложь.
• Вещественные числа сравнивают с допуском: fabs(a - b) < EPS, где fabs — модуль из <math.h>, а EPS выбирается по задаче (для денег в рублях — 1e-9 с запасом).
• У float 24 бита мантиссы: целые числа больше 2²⁴ = 16 777 216 хранятся уже не все. Поэтому в курсе вещественный тип — double; float — только там, где этого требует библиотека.

В Linux программа с <math.h> может потребовать при сборке ключ -lm в конце команды — подключить библиотеку математических функций: gcc … float.c -o float -lm. В Windows (MinGW) он не нужен.

Тип char — целое в 1 байт. Символ хранится своим кодом по таблице ASCII: 'A' — 65, 'a' — 97, '0' — 48, пробел — 32. Символьный литерал пишется в одинарных кавычках и равен числу: 'A' == 65 истинно.

/* Символ и его код */
#include <stdio.h>

int main(void)
{
    char letter = 'A';
    printf("%c = %d\n", letter, letter);
    printf("%c\n", letter + 2);          /* следующие буквы идут подряд */

    char digit = '7';
    int value = digit - '0';              /* символ цифры → число */
    printf("'%c' - '0' = %d\n", digit, value);
    return 0;
}

A = 65
C
'7' - '0' = 7

%c выводит число как символ, %d — как число. Цифры '0'…'9' в таблице идут подряд (коды 48–57), поэтому digit - '0' даёт значение цифры. Это используется при разборе строк (раздел 11).

Когда в выражении встречаются разные типы, C приводит их к общему по правилам неявного преобразования: char и short → int; целое и вещественное → double; знаковое и беззнаковое того же размера → беззнаковое (пункт 03).

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

int sum = 7, count = 2;
double avg = sum / count;               /* 3.000000: деление целых — целое */
double avg2 = (double)sum / count;     /* 3.500000 */

(double)sum — явное преобразование (приведение типа): значение sum превращается в double до деления, и деление становится вещественным. Скобки (double)(sum / count) не помогут: сначала выполнится целое деление, а преобразуется уже 3.

Вещественное → целое отбрасывает дробную часть (не округляет): (int)3.99 равно 3, (int)-3.99 равно −3. Для округления к ближайшему есть функция round из <math.h>: (int)round(3.99) равно 4. Если вещественное значение не помещается в целый тип — неопределённое поведение.

Литерал — значение, записанное прямо в тексте программы. Его тип определяется записью:

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

#define SEATS 45                /* макрос: препроцессор заменит SEATS на 45 до компиляции */
const double VAT_RATE = 0.20;   /* константа: переменная, которую нельзя изменить */
enum { MONTHS = 12 };          /* перечисление: целая константа с именем */

• #define — замена текста препроцессором (раздел 1, пункт 06). У макроса нет типа, его не видно в отладчике, но им можно задать размер массива. Без точки с запятой и знака равенства.
• const — переменная только для чтения: VAT_RATE = 0.18; не соберётся (error: assignment of read-only variable). Есть тип, видна в отладчике.
• enum — именованные целые константы; удобен для набора связанных значений: enum { RED, GREEN, BLUE }; — 0, 1, 2.

Все типы этого раздела — простые (скалярные): значение — одно число. Из них строятся остальные:

Массив, указатель и функция — производные типы: они строятся из другого типа («массив int», «указатель на double»). Массив и структура — структурированные: в одной переменной несколько значений. Своего типа «строка», как в Pascal или Python, в C нет — строка это массив char.