1.3. Переменные и именованные константы

Теория

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

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

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

Переменная как объект

В языке C важным является понятие объекта. Объект — это область памяти, с которой программа может работать. Если у этой области памяти есть имя, то к ней можно обращаться по этому имени.

Переменная — это частный случай объекта. Её можно понимать как пару:

имя → значение

Например:

int age = 18;

Здесь age — имя переменной, а 18 — значение, которое записано в выделенную для переменной область памяти.

Позже, при изучении указателей, будет важно понимать, что у объекта есть не только имя и значение, но и адрес. Пока достаточно запомнить: переменная хранит значение определённого типа.

Зачем переменной нужен тип

Тип переменной сообщает компилятору:

Например, переменная типа int предназначена для целых чисел, а переменная типа double — для вещественных чисел.

int count = 10;
double price = 19.95;

В памяти оба значения представлены двоичными кодами, но интерпретируются они по-разному, потому что имеют разные типы.

Определение переменных

Перед использованием переменная должна быть определена. Определение переменной сообщает компилятору её тип и имя.

Общая форма:

тип список_имен_переменных;

Если переменных одного типа несколько, их можно перечислить через запятую:

int number, row;
float x, y, z;

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

int value;   /* правильно */
int value    /* ошибка: нет точки с запятой */

Целочисленные типы

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

Примеры:

char symbol;
short smallNumber;
int count;
long distance;
long long bigValue;

Тип char формально относится к целочисленным типам, потому что символ хранится как числовой код. Поэтому с символами можно выполнять некоторые целочисленные операции.

char letter = 'A';
int code = letter;

Знаковые и беззнаковые целые типы

Целочисленные типы могут быть знаковыми и беззнаковыми.

Если перед целым типом не указано unsigned, обычно подразумевается знаковый вариант.

int a;          /* обычно signed int */
signed int b;   /* явно знаковый int */
unsigned int c; /* беззнаковый int */

Для краткости можно писать:

signed x;    /* то же, что signed int x */
unsigned y;  /* то же, что unsigned int y */

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

unsigned int studentsCount;
unsigned char byteCode;

Почему signed и unsigned отличаются

У знаковых и беззнаковых типов по-разному интерпретируется старший бит внутреннего представления.

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

Упрощённый пример для 8 бит:

Тип Примерный диапазон
signed char от -128 до 127
unsigned char от 0 до 255

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

unsigned int x = 0;
x = x - 1;   /* результат не -1, а большое unsigned-значение */

Примеры объявлений целочисленных переменных

char symbol, cc;
unsigned char code;
int number, row;
unsigned long longNumber;

Разберём эти строки:

Вещественные типы

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

Примеры:

float x, y;
double distance;
long double preciseValue;

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

Примеры объявлений вещественных переменных

float x, X, cc3, pot_8;
double e, Stop, B4;

Здесь важно помнить, что C различает регистр букв. Поэтому x и X — две разные переменные.

Имена cc3, pot_8, B4 являются допустимыми, потому что цифры в них стоят не на первом месте.

Размеры и диапазоны типов

Размеры типов зависят от компилятора, платформы и стандарта, но стандарт C задаёт минимальные требования. Например, short и int должны иметь не менее 16 бит, а long — не менее 32 бит.

В старых учебных таблицах часто встречается модель, где int занимает 16 бит. На современных ПК int часто занимает 32 бита, поэтому конкретные диапазоны могут отличаться. Для переносимого кода лучше не привязываться к одному размеру типа.

Тип Что хранит Комментарий
char малое целое значение / символ обычно 1 байт
short короткое целое не меньше 16 бит
int основное целое часто 32 бита на современных системах
long длинное целое не меньше 32 бит
long long очень длинное целое не меньше 64 бит
float вещественное число обычно 32 бита
double вещественное число двойной точности обычно 64 бита
long double вещественное число повышенной точности зависит от реализации

Чтобы узнать размер типа в конкретной среде, используется операция sizeof:

printf("%zu\n", sizeof(int));
printf("%zu\n", sizeof(double));

Инициализация переменных

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

int count;
printf("%d", count);  /* ошибка по смыслу: count не инициализирована */

Чтобы сразу задать начальное значение, используется инициализация.

Общая форма:

тип имя_переменной = начальное_значение;

Примеры:

float pi = 3.1415, cc = 1.23;
unsigned int year = 1997;
int count = 0;

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

int x = 10;  /* инициализация */

x = 20;      /* присваивание */

Почему важно инициализировать переменные

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

Плохой вариант:

int sum;
sum = sum + 10;

Здесь sum используется до того, как ей задано начальное значение.

Правильный вариант:

int sum = 0;
sum = sum + 10;

В учебных программах лучше сразу инициализировать переменные, особенно счётчики, суммы, произведения и флаги.

Именованные константы

Именованная константа — это постоянное значение, которому дано имя. Благодаря этому программа становится понятнее.

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

area = 3.14159 * radius * radius;

Лучше:

const double PI = 3.14159;
area = PI * radius * radius;

Теперь ясно, что PI — это число π, а не случайное магическое число.

В C есть несколько способов задать именованные константы:

  1. через enum;
  2. через const;
  3. через директиву препроцессора #define.

Именованные константы через enum

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

enum BOOLEAN { NO, YES };

Здесь NO получает значение 0, а YES — значение 1.

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

enum MODE { MODE_VIEW, MODE_EDIT, MODE_DELETE };

enum MODE currentMode = MODE_VIEW;

Такой код читается лучше, чем использование чисел 0, 1, 2 без объяснения их смысла.

Именованные константы через const

Квалификатор const указывает, что объект доступен только для чтения после инициализации.

Общая форма:

const тип имя_константы = значение;

Примеры:

const double E = 2.718282;
const long MAX_DISTANCE = 99999999;
const int DAYS_IN_WEEK = 7;

После такого определения нельзя изменить значение константы:

const int LIMIT = 100;

LIMIT = 200;  /* ошибка */

В старых вариантах C можно встретить запись без явного типа:

const F = 765;

Для современного учебного кода лучше всегда писать тип явно:

const int F = 765;

Именованные константы через #define

Директива #define задаёт текстовую подстановку на этапе препроцессорной обработки.

Общая форма:

#define ИМЯ_КОНСТАНТЫ значение

Пример:

#define PI 3.14159
#define MAX_SIZE 100

В конце директивы #define не ставится точка с запятой.

#define MAX_SIZE 100;  /* плохая ошибка: ; станет частью подстановки */

В отличие от const, директива #define не создаёт обычный типизированный объект. Препроцессор просто заменяет имя на текст до этапа компиляции.

Разница между const и #define

Снаружи эти два варианта могут выглядеть похожими:

const double E = 2.718282;

#define EULER 2.718282

Но работают они по-разному.

Способ Что происходит
const создаётся объект с типом, доступный только для чтения
#define препроцессор выполняет текстовую замену до компиляции

Если написать:

#define EULER 2.718282

double mix = EULER;
d = alfa * EULER;

После препроцессорной обработки компилятор получит примерно такой текст:

double mix = 2.718282;
d = alfa * 2.718282;

То есть имя EULER исчезает ещё до настоящей компиляции.

Схема работы препроцессорной подстановки

Ниже показана упрощённая схема того, как текст программы меняется после обработки директив #define.

Текст до препроцессора
#define PI 3.141593
#define ZERO 0.0

double circle = PI * r * r;

/* Сравнение с константой ZERO */
if (x == ZERO)
{
    printf("ZERO");
}
Текст после препроцессора
double circle = 3.141593 * r * r;

/* Сравнение с константой ZERO */
if (x == 0.0)
{
    printf("ZERO");
}

Обрати внимание: подстановка выполняется в коде, но не выполняется внутри комментариев и строковых литералов. Поэтому слово ZERO в комментарии и строке "ZERO" осталось без изменений.

Когда использовать const, enum и #define

На начальном этапе удобно придерживаться таких правил:

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

Стандартные именованные константы

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

Для целочисленных типов используется:

#include <limits.h>

После подключения можно использовать, например:

CHAR_BIT
INT_MIN
INT_MAX
LONG_MAX

Для вещественных типов используется:

#include <float.h>

После подключения доступны, например:

FLT_MIN
FLT_MAX
DBL_MIN
DBL_MAX
DBL_EPSILON

Такой подход помогает писать более переносимые программы: программист использует стандартное имя, а конкретное значение берётся из реализации компилятора.

Пример использования limits.h и float.h

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void)
{
    printf("CHAR_BIT = %d\n", CHAR_BIT);
    printf("INT_MIN = %d\n", INT_MIN);
    printf("INT_MAX = %d\n", INT_MAX);

    printf("FLT_MAX = %e\n", FLT_MAX);
    printf("DBL_EPSILON = %e\n", DBL_EPSILON);

    return 0;
}

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

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

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

#define MAX_SIZE 100
const int DAYS_IN_WEEK = 7;
const double PI = 3.14159;

Такой стиль помогает быстро отличать постоянные значения от обычных переменных.

Сравни:

int maxSize = 100;        /* обычная переменная */
const int MAX_SIZE = 100; /* именованная константа */

Типичные ошибки

Ошибка 1. Использование переменной без определения

count = 10;  /* ошибка, если count ранее не была определена */

Правильно:

int count = 10;

Ошибка 2. Использование неинициализированной переменной

int sum;
sum = sum + 5;

Перед использованием sum нужно задать начальное значение.

int sum = 0;
sum = sum + 5;

Ошибка 3. Точка с запятой после #define

#define SIZE 100;

Точка с запятой станет частью подстановки. Лучше писать так:

#define SIZE 100

Ошибка 4. Попытка изменить const-константу

const int LIMIT = 10;
LIMIT = 20;  /* ошибка */

Ошибка 5. Смешивание signed и unsigned без необходимости

int a = -1;
unsigned int b = 10;

if (a < b)
{
    printf("a меньше b");
}

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

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

#include <stdio.h>
#include <limits.h>

#define MAX_STUDENTS 30

int main(void)
{
    const double PASS_MARK = 3.0;

    int studentsCount = 25;
    double averageMark = 4.35;
    unsigned int groupCode = 101;

    printf("Students: %d\n", studentsCount);
    printf("Average mark: %.2f\n", averageMark);
    printf("Max students: %d\n", MAX_STUDENTS);
    printf("Pass mark: %.1f\n", PASS_MARK);
    printf("Max int: %d\n", INT_MAX);

    return 0;
}

В этом примере:

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

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

  1. Что такое переменная?
  2. Зачем переменной нужен тип?
  3. Чем отличается signed int от unsigned int?
  4. Почему нельзя использовать локальную переменную до инициализации?
  5. Чем инициализация отличается от присваивания?
  6. Какие есть способы создания именованных констант?
  7. Чем const отличается от #define?
  8. Почему после #define обычно не ставят точку с запятой?
  9. Для чего нужны limits.h и float.h?