1.2. Литералы

Теория

Зачем нужен этот пункт

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

Например, в строке:

int age = 18;

число 18 — это целочисленный литерал. В строке:

printf("Hello\n");

"Hello\n" — строковый литерал, а \n внутри него — управляющая последовательность перехода на новую строку.

В этом пункте нужно научиться различать виды литералов, понимать их запись и не путать символы, строки, целые числа, вещественные числа и специальные константы.

Что такое константа и литерал

Константа — это значение, которое не изменяется во время выполнения программы. Если значение записано прямо в тексте программы, его обычно называют литералом.

Примеры литералов:

10          /* целочисленный литерал */
3.14        /* вещественный литерал */
'A'         /* символьный литерал */
"Hello"     /* строковый литерал */

Литерал сам по себе не имеет имени. Он просто задаёт конкретное значение. Например:

int count = 10;

Здесь count — имя переменной, а 10 — литерал.

Основные виды констант в C

В классическом C можно выделить несколько основных видов констант:

  1. символьные константы;
  2. целые константы;
  3. вещественные константы;
  4. нулевой указатель;
  5. константы перечисляемого типа.

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

Символьные константы

Символьная константа задаёт один символ. Она записывается в апострофах, то есть в одинарных кавычках:

'A'
'a'
'8'
'0'
'+'
';'

Важно не путать символ и число. Например:

'8'   /* символ 8 */
8     /* целое число 8 */

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

char symbol = 'A';
int code = symbol;

В этом примере переменная code получит числовой код символа 'A' в используемой кодировке.

Управляющие последовательности

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

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

Последовательность Назначение
\n переход на новую строку
\t горизонтальная табуляция
\r возврат каретки к началу строки
\\ символ обратной косой черты
\' апостроф, то есть одинарная кавычка
\" двойная кавычка
\0 нулевой символ
\a звуковой сигнал
\b возврат на одну позицию назад
\f перевод страницы
\v вертикальная табуляция
\? знак вопроса

Например:

printf("First line\nSecond line");

На экране получится две строки:

First line
Second line

Символы через числовой код

Символ можно задать не только обычной записью вроде 'A', но и через его числовой код.

Восьмеричная запись

Формат:

'\ddd'

Здесь d — восьмеричная цифра от 0 до 7.

'\017'
'\233'

Шестнадцатеричная запись

Формат:

'\xhh'

Здесь h — шестнадцатеричная цифра: 0-9, A-F или a-f.

'\x0b'
'\x1A'

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

Один символ и несколько символов в записи

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

'\n'

В исходном тексте здесь два видимых символа: обратная косая черта и буква n. Но для программы это один символ — перевод строки.

То же самое относится к '\t', '\\', '\0' и другим escape-последовательностям.

Целые константы

Целые константы задают целые числа. В языке C они могут записываться в десятичной, восьмеричной и шестнадцатеричной системе счисления.

Десятичные целые константы

Десятичная константа записывается обычными десятичными цифрами. Если это не число 0, она не должна начинаться с нуля.

44
684
0
1024

Восьмеричные целые константы

Если целая константа начинается с нуля, она воспринимается как восьмеричная.

016

Запись 016 означает не десятичное число 16, а восьмеричное число 16, то есть десятичное 14.

Это частая ошибка начинающих: случайно поставить ноль перед числом.

int a = 16;   /* десятичное 16 */
int b = 016;  /* восьмеричное 16, то есть десятичное 14 */

Шестнадцатеричные целые константы

Шестнадцатеричная константа начинается с 0x или 0X.

0x16
0XFF

Примеры:

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

Суффиксы целых констант

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

Суффикс Смысл Пример
U или u беззнаковая целая константа 50000U
L или l длинная целая константа 500L
UL, LU, ul и т.п. беззнаковая длинная целая константа 2424242424UL
LL или ll целая константа типа long long 123LL

Лучше не использовать строчную букву l как суффикс, потому что она может быть похожа на цифру 1.

500L   /* читается лучше */
500l   /* можно перепутать с 5001 */

Как компилятор выбирает тип целой константы

Тип целой константы зависит от её записи, значения и суффикса. В старых учебных таблицах часто показываются диапазоны для систем, где int занимает 16 бит. В современных компиляторах размер int часто равен 32 битам, поэтому конкретные диапазоны могут отличаться.

Главная идея такая: если число помещается в обычный int, компилятор может выбрать int. Если число слишком большое, выбирается более широкий тип, например long или long long.

100       /* обычно int */
100L      /* long */
100U      /* unsigned int */
100UL     /* unsigned long */
100LL     /* long long */

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

Вещественные константы

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

Примеры:

44.
3.14159
44e0
.314159E1
0.0

Вещественная константа может состоять из нескольких частей:

Не обязательно указывать все части сразу. Например, запись 44. допустима, потому что есть десятичная точка. Запись .5 тоже допустима, потому что есть дробная часть.

44.     /* 44.0 */
.5      /* 0.5 */
1e3     /* 1000.0 */
1.5e-2  /* 0.015 */

Типы вещественных констант

По умолчанию вещественная константа имеет тип double. Это значит, что запись:

3.14

обычно рассматривается как значение типа double, а не float.

Чтобы явно указать другой вещественный тип, используются суффиксы.

Суффикс Тип Пример
F или f float 3.14159F
без суффикса double 3.14159
L или l long double 3.14L
float x = 3.14F;
double y = 3.14;
long double z = 3.14L;

Диапазоны вещественных типов

Вещественные типы различаются размером в памяти, диапазоном значений и точностью.

Тип Обычно размер Назначение
float 32 бита вещественный тип одинарной точности
double 64 бита вещественный тип двойной точности
long double зависит от реализации повышенная точность, если поддерживается компилятором

В учебных задачах обычно достаточно понимать: double чаще всего точнее, чем float, поэтому для вычислений с вещественными числами часто используют именно double.

Нулевой указатель

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

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

0
0L
NULL

NULL обычно определяется в стандартных заголовочных файлах. Его используют для повышения читаемости кода.

int *ptr = NULL;

Это означает: переменная ptr является указателем на int, но пока не указывает на реальный объект.

Важно не путать нулевой указатель, символ '0' и нулевой символ '\0'. Это разные вещи.

Запись Смысл
0 целочисленная константа ноль
NULL нулевой указатель
'0' символ цифры ноль
'\0' нулевой символ

Константы перечисляемого типа

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

Общий вид:

enum имя_перечисления { список_констант };

Примеры:

enum { ONE = 1, TWO, THREE, FOUR };

enum DAY {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
};

enum BOOLEAN { NO, YES };

Если значения не указаны явно, первая константа получает значение 0, следующая — 1, затем 2 и так далее.

enum BOOLEAN { NO, YES };

Здесь NO равно 0, а YES равно 1.

Если одно значение задано явно, следующие продолжают счёт от него.

enum { ONE = 1, TWO, THREE, FOUR };

Здесь ONE равно 1, TWO равно 2, THREE равно 3, а FOUR равно 4.

Зачем нужны enum-константы

Перечисления делают программу понятнее. Вместо непонятных чисел можно использовать осмысленные имена.

Плохо читается:

int status = 1;

Лучше:

enum STATUS { ERROR, OK };

enum STATUS status = OK;

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

Строковые литералы

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

"Hello"
"Введите число:"
"Result = "

Строковый литерал может содержать обычные символы и управляющие последовательности.

"First line\nSecond line"
"Name:\tIvan"
"Quote: \""

Строки используются, например, при выводе текста:

printf("Hello, world!\n");

Символ и строка — не одно и то же

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

'F'   /* символ */
"F"   /* строка */

Это разные записи и разные объекты.

Символ 'F' занимает место для одного символа. Строка "F" содержит символ F и специальный завершающий нулевой символ '\0'.

'F'  → один символ
"F"  → 'F' + '\0'

Поэтому строка "F" требует больше памяти, чем символ 'F'.

Нулевой символ в конце строки

В языке C строка хранится как последовательность символов, в конце которой автоматически добавляется нулевой символ '\0'.

"cat"

В памяти такая строка выглядит примерно так:

'c'  'a'  't'  '\0'

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

Поэтому количество байтов, выделяемое для строкового литерала, на один больше количества видимых символов.

"cat"   /* 3 видимых символа + '\0' = 4 символа в памяти */

Перенос строкового литерала на несколько строк

Длинный строковый литерал можно записать в несколько частей. В C соседние строковые литералы, между которыми находятся только пробельные символы, объединяются в один.

"Hello, "
"world!"

Для компилятора это то же самое, что:

"Hello, world!"

Это удобно, если строка слишком длинная:

printf("This is a very long message "
       "that is split into two parts.\n");

Продолжение строки через обратную косую черту

В C также существует способ продолжить строковый литерал на следующей строке с помощью обратной косой черты в конце строки.

"Шалтай-Болтай \
сидел на стене."

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

На практике чаще используют соседние строковые литералы:

"Шалтай-Болтай "
"сидел на стене."

Типичные ошибки при работе с литералами

Ошибка 1. Путаница символа и строки

char c = "A";   /* ошибка */
char c = 'A';   /* правильно */

'A' — это символ, а "A" — строка.

Ошибка 2. Случайный ноль перед числом

int x = 010;

Это не десятичное 10, а восьмеричное 10, то есть десятичное 8.

Ошибка 3. Неправильная запись обратной косой черты

printf("C:\new_folder");   /* ошибка по смыслу */

Здесь \n будет воспринято как переход на новую строку. Чтобы вывести обратную косую черту, её нужно записать как \\.

printf("C:\\new_folder");

Ошибка 4. Путаница '0' и '\0'

'0'   /* символ цифры 0 */
'\0'  /* нулевой символ */

Символ '0' имеет код символа цифры, а '\0' означает символ с нулевым кодом.

Ошибка 5. Использование запятой вместо точки

double x = 3,14;   /* ошибка для записи числа 3.14 */

В C дробная часть вещественного числа отделяется точкой, а не запятой.

double x = 3.14;

Мини-разбор фрагмента программы

Рассмотрим пример:

#include <stdio.h>

int main(void)
{
    char letter = 'A';
    int number = 016;
    double pi = 3.14159;
    enum BOOLEAN { NO, YES };

    printf("letter = %c\n", letter);
    printf("number = %d\n", number);
    printf("pi = %f\n", pi);

    return 0;
}

В этом фрагменте:

Если вывести number, результат будет 14, потому что 016 записано в восьмеричной системе счисления.

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Чем отличается 'A' от "A"?
  2. Что означает управляющая последовательность \n?
  3. Почему 016 — это не десятичное 16?
  4. Как записать шестнадцатеричную константу?
  5. Какой тип имеет вещественная константа без суффикса?
  6. Для чего нужен символ '\0' в строках?
  7. Чем отличается '0' от '\0'?
  8. Что делает перечисление enum?