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— целый тип, обычно используется для символов;shortилиshort int— короткий целый тип;int— основной целый тип;longилиlong int— длинный целый тип;long long— целый тип длиной не менее 64 бит.
Примеры:
char symbol;
short smallNumber;
int count;
long distance;
long long bigValue;
Тип char формально относится к целочисленным типам, потому что
символ хранится как числовой код. Поэтому с символами можно выполнять
некоторые целочисленные операции.
char letter = 'A';
int code = letter;
Знаковые и беззнаковые целые типы
Целочисленные типы могут быть знаковыми и беззнаковыми.
signed— тип может хранить отрицательные и положительные значения;unsigned— тип хранит только неотрицательные значения.
Если перед целым типом не указано 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;
Разберём эти строки:
char symbol, cc;— две переменные типаchar;unsigned char code;— беззнаковый символьный/байтовый тип;int number, row;— две целочисленные переменные;unsigned long longNumber;— беззнаковая длинная целая переменная.
Вещественные типы
Вещественные типы используются для чисел с дробной частью и для вычислений, где результат не обязательно является целым числом.
float— вещественный тип одинарной точности;double— вещественный тип двойной точности;long double— вещественный тип повышенной точности.
Примеры:
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 есть несколько способов задать именованные константы:
- через
enum; - через
const; - через директиву препроцессора
#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— для обычных типизированных постоянных значений:PI,RATE,LIMIT. -
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;
}
В этом примере:
MAX_STUDENTS— препроцессорная именованная константа;PASS_MARK— типизированная константа черезconst;studentsCount— переменная типаint;averageMark— переменная типаdouble;groupCode— беззнаковая целая переменная;INT_MAX— стандартная константа изlimits.h.
Что нужно запомнить
- Переменная — это именованная область памяти, значение которой может изменяться.
- Перед использованием переменная должна быть определена.
- Тип переменной определяет размер памяти, диапазон значений и допустимые операции.
- Целые типы могут быть знаковыми и беззнаковыми.
unsigned-тип не хранит отрицательные значения.- Вещественные типы:
float,double,long double. - Локальные автоматические переменные нужно инициализировать перед использованием.
- Именованные константы можно создавать через
enum,constи#define. constсоздаёт объект только для чтения.#defineвыполняет текстовую подстановку до компиляции.- Для предельных значений типов используются заголовки
limits.hиfloat.h.
Самопроверка перед переходом дальше
- Что такое переменная?
- Зачем переменной нужен тип?
- Чем отличается
signed intотunsigned int? - Почему нельзя использовать локальную переменную до инициализации?
- Чем инициализация отличается от присваивания?
- Какие есть способы создания именованных констант?
- Чем
constотличается от#define? - Почему после
#defineобычно не ставят точку с запятой? - Для чего нужны
limits.hиfloat.h?