5.7. Классы памяти и организация программ
Теория
Зачем нужен этот пункт
До этого момента мы в основном рассматривали функции как самостоятельные части программы: у функции есть параметры, локальные переменные, возвращаемое значение и тело. Но в реальных программах важно понимать не только какого типа переменная, но и где она существует, как долго она существует и из каких частей программы к ней можно обратиться.
Эти вопросы связаны с классами памяти и организацией программы. Они особенно важны, когда программа состоит не из одной функции, а из нескольких функций и нескольких файлов.
После изучения этого пункта нужно понимать:
- чем локальная автоматическая переменная отличается от локальной статической;
- что такое глобальный объект;
- почему локальная переменная может «скрыть» глобальную;
- как связаны динамическая память и указатели;
- зачем нужен спецификатор
extern; - чем описание объекта отличается от его определения.
Три важных вопроса о любом объекте
Для переменной, массива, указателя или другого объекта в Си полезно всегда задавать три вопроса.
1. Где объект виден?
Это область видимости. Например, переменная, определённая внутри функции, обычно видна только внутри этой функции. Переменная, определённая вне всех функций, может быть видна нескольким функциям.
2. Как долго объект существует?
Это время жизни объекта. Одни переменные создаются при входе в блок и исчезают при выходе из него. Другие существуют всё время работы программы. Динамические объекты существуют до тех пор, пока программист явно не освободит выделенную память.
3. Как объект связан с другими файлами программы?
Если программа состоит из нескольких файлов, нужно понимать, может ли объект использоваться в другом
файле. Для этого применяется понятие внешнего объекта и спецификатор extern.
В языке Си используются спецификаторы классов памяти:
auto, register, static, extern.
Кроме них, при работе с указателями часто используется динамическая память, выделяемая во время
выполнения программы.
Автоматическая память: обычные локальные переменные
Если переменная определена внутри блока, например внутри тела функции, и перед ней не указан другой класс памяти, она считается объектом автоматической памяти.
void func(void)
{
int x;
double sum;
}
Переменные x и sum существуют только во время выполнения блока функции
func. При входе в функцию под них выделяется память. При выходе из функции эта память
освобождается, а сами переменные исчезают.
При следующем вызове функции переменные будут созданы заново. Их прошлые значения не сохраняются. Если переменная не инициализирована явно, её начальное значение неопределено.
Спецификатор auto можно записать явно, но обычно этого не делают:
void func(void)
{
auto int x;
}
Такая запись почти не используется, потому что auto и так подразумевается для обычных
локальных переменных.
Пример: автоматическая переменная создаётся заново
Рассмотрим функцию, внутри которой есть локальная переменная k. Каждый раз при вызове
функции переменная создаётся заново и снова получает начальное значение 1.
#include <stdio.h>
/* Переменная автоматической памяти */
void autofunc(void)
{
int k = 1;
printf("\tK=%d", k);
k++;
}
int main(void)
{
int i;
for (i = 0; i < 5; i++)
autofunc();
return 0;
}
Результат:
K=1 K=1 K=1 K=1 K=1
Хотя внутри функции выполняется k++, это не влияет на следующий вызов функции.
После выхода из функции автоматическая переменная исчезает. При новом вызове создаётся новая
переменная k, которая снова инициализируется значением 1.
Спецификатор register
Спецификатор register также относится к локальным объектам автоматической памяти.
Он сообщает компилятору, что переменная будет часто использоваться и её желательно хранить в регистре
процессора.
void count(void)
{
register int i;
for (i = 0; i < 1000; i++)
{
/* действия цикла */
}
}
В классическом Си это была подсказка компилятору для ускорения доступа к переменной. Современные
компиляторы обычно сами хорошо оптимизируют программу, поэтому register применяется редко.
Важно помнить: к переменной, объявленной как register, нельзя применять операцию получения
адреса &, потому что она может не иметь обычного адреса в памяти.
register int x;
/* Ошибка: адрес register-переменной получать нельзя */
scanf("%d", &x);
Для начинающего программиста практическое правило простое: почти всегда используйте обычные локальные
переменные, а register пока рассматривайте как исторически важную возможность языка.
Локальная статическая переменная
Если локальная переменная объявлена со спецификатором static, она остаётся локальной по
области видимости, но меняет своё время жизни.
void func(void)
{
static int k = 1;
}
Такая переменная:
- видна только внутри своего блока или функции;
- создаётся и инициализируется только один раз;
- сохраняет своё значение между вызовами функции;
- существует всё время выполнения программы.
Это удобно, когда функция должна «помнить» информацию о предыдущих вызовах, но эту информацию не нужно делать глобальной.
Пример: static сохраняет значение между вызовами
Теперь изменим предыдущий пример: добавим перед переменной k спецификатор
static.
#include <stdio.h>
/* Локальная переменная статической памяти */
void stat(void)
{
static int k = 1;
printf("\tK=%d", k);
k++;
}
int main(void)
{
int i;
for (i = 0; i < 5; i++)
stat();
return 0;
}
Результат:
K=1 K=2 K=3 K=4 K=5
В этом случае переменная k не создаётся заново при каждом вызове. Она создаётся один раз,
получает начальное значение 1, затем после каждого вызова сохраняет новое значение.
Поэтому первый вызов выводит 1, второй — 2, третий — 3 и так далее.
Автоматическая и статическая локальная переменная: главное отличие
| Свойство | Обычная локальная переменная | Локальная static-переменная |
|---|---|---|
| Где видна | Внутри блока | Внутри блока |
| Когда создаётся | При каждом входе в блок | Один раз за всё время работы программы |
| Когда исчезает | При выходе из блока | При завершении программы |
| Сохраняет ли значение между вызовами | Нет | Да |
| Типичное применение | Временные вычисления | Счётчики вызовов, сохранение состояния функции |
Глобальные объекты
Объект, определённый вне всех функций, называется внешним объектом. Если он расположен в начале файла, то функции этого файла могут обращаться к нему как к глобальному объекту.
#include <stdio.h>
int n = 5; /* Глобальная переменная */
void func(void)
{
printf("\tN=%d", n);
n--;
}
int main(void)
{
int i;
for (i = 0; i < 5; i++)
{
func();
n += 2;
}
return 0;
}
Результат:
N=5 N=6 N=7 N=8 N=9
Переменная n определена вне функций main и func, поэтому обе функции
работают с одним и тем же объектом. Функция func уменьшает значение n на 1,
а функция main после каждого вызова увеличивает его на 2.
Глобальные переменные полезны, когда некоторое состояние действительно должно быть общим для нескольких функций. Но злоупотреблять ими не стоит: чем больше глобальных данных, тем сложнее понимать, какая функция и в какой момент изменила значение.
Затенение глобального имени
Если внутри блока объявить локальную переменную с таким же именем, как у глобальной, локальная переменная «затенит» глобальную. Внутри этого блока имя будет относиться уже к локальному объекту.
#include <stdio.h>
int value = 10; /* Глобальная переменная */
void show_global(void)
{
printf("global value = %d\n", value);
}
int main(void)
{
int value = 100; /* Локальная переменная скрыла глобальную */
printf("local value = %d\n", value);
show_global();
return 0;
}
Возможный результат:
local value = 100
global value = 10
В функции main имя value обозначает локальную переменную. Глобальная переменная
с таким же именем в этой функции становится недоступной по имени. Но в функции show_global
локальной переменной value нет, поэтому там используется глобальный объект.
На практике лучше избегать одинаковых имён для глобальных и локальных объектов. Такой код может быть правильным с точки зрения компилятора, но он легко приводит к ошибкам при чтении и сопровождении программы.
Динамическая память
Динамическая память выделяется во время выполнения программы. В отличие от автоматической переменной,
динамический объект не исчезает автоматически при выходе из функции. Он существует до тех пор, пока его
явно не освободят с помощью функции free.
В стандартном Си для работы с динамической памятью используются функции из заголовочного файла
stdlib.h:
#include <stdlib.h>
malloc(...)
free(...)
Функция malloc выделяет участок памяти и возвращает указатель на него. Функция
free освобождает ранее выделенный участок.
int *p;
p = (int *)malloc(sizeof(int));
if (p != NULL)
{
*p = 25;
printf("%d\n", *p);
free(p);
p = NULL;
}
Важно понимать: сама динамическая память доступна не «по имени», а через указатель. Поэтому доступность динамического объекта зависит от того, где виден указатель, хранящий его адрес.
Три варианта работы с динамической памятью
После выделения динамической памяти нужно следить за указателем, через который доступен выделенный участок. Возможны три типичных варианта.
1. Указатель — локальная автоматическая переменная
Если указатель объявлен внутри функции как обычная локальная переменная, то после выхода из функции
сам указатель исчезает. Если до этого не вызвать free, адрес выделенного участка будет потерян.
void bad_example(void)
{
char *p;
p = (char *)malloc(1);
if (p == NULL)
return;
*p = 'A';
/* Ошибка стиля: перед выходом нужно вызвать free(p) */
}
Здесь динамическая память была выделена, но не освобождена. После выхода из функции указатель
p исчезнет, и программа уже не сможет нормально обратиться к выделенному участку.
2. Указатель — локальная static-переменная
Если указатель локальный, но статический, он сохраняет своё значение между вызовами функции. Это позволяет выделить память один раз и использовать её при последующих вызовах.
#include <stdio.h>
#include <stdlib.h>
void dynam(void)
{
static char *p = NULL;
if (p == NULL)
{
p = (char *)malloc(1);
if (p == NULL)
return;
*p = 'A';
}
printf("\t%c", *p);
(*p)++;
}
int main(void)
{
int i;
for (i = 0; i < 5; i++)
dynam();
return 0;
}
Результат:
A B C D E
Переменная p видна только внутри функции dynam, но её значение сохраняется между
вызовами. При первом вызове память выделяется и в неё записывается символ 'A'. При следующих
вызовах используется тот же участок памяти.
В реальной программе для такого участка памяти нужно предусмотреть отдельное освобождение, когда он больше не нужен.
3. Указатель — глобальный объект
Если указатель определён вне функций, он может быть доступен нескольким функциям. Тогда динамический объект, адресуемый этим указателем, также становится доступным из этих функций.
#include <stdio.h>
#include <stdlib.h>
char *uk = NULL; /* Глобальный указатель */
void dynam1(void)
{
printf("\t%c", *uk);
(*uk)++;
}
int main(void)
{
int i;
uk = (char *)malloc(1);
if (uk == NULL)
return 1;
*uk = 'A';
for (i = 0; i < 5; i++)
{
dynam1();
(*uk)++;
}
free(uk);
uk = NULL;
return 0;
}
Результат:
A C E G I
В функции main выделяется память и в неё записывается 'A'. Функция
dynam1 печатает символ и увеличивает его код на 1. После возврата в main
значение увеличивается ещё раз. Поэтому выводятся символы через один: A, C,
E, G, I.
Внешние объекты и программы из нескольких файлов
Небольшие учебные программы часто помещаются в один файл. Но более серьёзная программа обычно состоит из нескольких файлов. Каждый файл с частью исходного текста иногда называют программным модулем.
В Си нельзя определить одну функцию внутри другой функции. Поэтому все функции являются внешними объектами программы. У функций, даже если они находятся в разных файлах, должны быть разные имена.
Кроме функций, внешними объектами могут быть переменные, массивы и указатели, определённые вне всех функций.
int count;
double values[10];
char *message;
Если внешний объект определён в одном файле, а использовать его нужно в другом файле, во втором файле
нужно написать описание с ключевым словом extern.
Определение и описание объекта
Важно различать два понятия: определение и описание.
Определение создаёт объект и выделяет для него память. При определении объект можно инициализировать.
double summa[5];
char text[] = "C language";
long m = 1000;
Описание сообщает компилятору, что объект существует где-то в другом месте программы.
Описание не выделяет память заново. Для внешнего объекта используется extern.
extern double summa[];
extern char text[];
extern long m;
В описании нельзя заново инициализировать объект. Для массива во внешнем описании часто не указывают количество элементов, потому что память для массива уже выделена в месте его определения.
Пример организации программы из двух файлов
Пусть есть программа, состоящая из двух файлов: data.c и main.c.
В первом файле определим глобальную переменную и функцию для её изменения.
Файл data.c
#include <stdio.h>
int counter = 0; /* Определение внешнего объекта */
void increase_counter(void)
{
counter++;
}
Файл main.c
#include <stdio.h>
extern int counter; /* Описание внешнего объекта */
void increase_counter(void); /* Прототип внешней функции */
int main(void)
{
increase_counter();
increase_counter();
printf("counter = %d\n", counter);
return 0;
}
В файле data.c переменная counter определена, то есть для неё выделяется память.
В файле main.c написано extern int counter;. Это не создаёт новую переменную,
а сообщает компилятору: переменная counter уже существует в другом месте программы.
При компиляции нужно собрать оба файла вместе:
gcc main.c data.c -o program
Если скомпилировать только main.c, компоновщик не найдёт определение переменной
counter и функцию increase_counter.
static для внешних объектов
Спецификатор static может использоваться не только внутри функции, но и вне функций.
В этом случае он ограничивает доступность объекта пределами текущего файла.
static int hidden_counter = 0;
static void helper(void)
{
hidden_counter++;
}
Такие объекты нельзя использовать из другого файла через extern. Это полезно, когда переменная
или вспомогательная функция нужна только внутри одного файла и не должна становиться частью внешнего
интерфейса модуля.
Для начинающего программиста можно запомнить так:
staticвнутри функции сохраняет значение локальной переменной между вызовами;staticвне функции ограничивает видимость объекта текущим файлом.
Мини-разбор программы
Рассмотрим программу, в которой одновременно используются глобальная переменная, локальная автоматическая переменная и локальная статическая переменная.
#include <stdio.h>
int total_calls = 0; /* Глобальная переменная */
void print_info(void)
{
int local_counter = 1;
static int saved_counter = 1;
total_calls++;
printf("local=%d, saved=%d, total=%d\n",
local_counter, saved_counter, total_calls);
local_counter++;
saved_counter++;
}
int main(void)
{
int i;
for (i = 0; i < 4; i++)
print_info();
return 0;
}
Результат:
local=1, saved=1, total=1
local=1, saved=2, total=2
local=1, saved=3, total=3
local=1, saved=4, total=4
Разберём, почему получается именно так.
-
local_counter— обычная локальная переменная. Она создаётся заново при каждом вызове функцииprint_info, поэтому каждый раз снова равна1. -
saved_counter— локальная статическая переменная. Она видна только внутри функции, но сохраняет значение между вызовами, поэтому выводит1, затем2, затем3, затем4. -
total_calls— глобальная переменная. Она доступна функцииprint_infoи хранит общее количество вызовов.
Эта программа хорошо показывает, что область видимости и время жизни — разные вещи. Переменная
saved_counter локальна по области видимости, но существует всё время работы программы.
Типичные ошибки
Ошибка 1. Ожидать, что обычная локальная переменная сохранит значение
void func(void)
{
int k = 0;
k++;
printf("%d\n", k);
}
При каждом вызове k снова станет равной 0, затем увеличится до 1.
Если нужно сохранить значение между вызовами, используйте static.
Ошибка 2. Забыть освободить динамическую память
int *p;
p = (int *)malloc(sizeof(int));
if (p != NULL)
{
*p = 10;
}
/* free(p) забыли */
Если память больше не нужна, её нужно освободить:
free(p);
p = NULL;
Ошибка 3. Использовать локальный указатель после выхода из функции
int *bad_pointer(void)
{
int x = 10;
return &x; /* Ошибка: x исчезнет после выхода из функции */
}
Переменная x является автоматической локальной переменной. После выхода из функции её уже
не существует, поэтому возвращать её адрес нельзя.
Ошибка 4. Путать определение и extern-описание
/* file1.c */
int value = 10;
/* file2.c */
extern int value;
В первом файле объект определён. Во втором файле он только описан. Если написать
int value = 10; в двух разных файлах, это уже будут конфликтующие определения одного
внешнего объекта.
Ошибка 5. Случайно скрыть глобальную переменную локальной
int size = 100;
void func(void)
{
int size = 5;
printf("%d\n", size);
}
Внутри func будет использоваться локальная переменная size, а не глобальная.
Лучше избегать одинаковых имён для разных объектов.
Практические рекомендации
- Для временных вычислений внутри функции используйте обычные локальные переменные.
-
Используйте локальные
static-переменные только тогда, когда функция действительно должна сохранять своё состояние между вызовами. - Не делайте переменную глобальной только ради удобства. Сначала подумайте, можно ли передать её через параметры функции.
- Для динамической памяти всегда заранее продумывайте, где она выделяется и где освобождается.
-
После
freeполезно присваивать указателюNULL, чтобы случайно не использовать старый адрес. -
В многофайловой программе помещайте определения внешних объектов только в один
.c-файл, а в остальных файлах используйтеextern-описания. - Не используйте одинаковые имена для локальных и глобальных переменных.
-
Вспомогательные функции и переменные, нужные только внутри одного файла, можно объявлять как
staticвне функций.
Что нужно запомнить
- Обычная локальная переменная имеет автоматическую память: создаётся при входе в блок и исчезает при выходе из него.
-
autoобычно не пишут явно, потому что локальные переменные и так автоматические. -
register— подсказка компилятору хранить переменную в регистре; на практике сейчас используется редко. -
Локальная
static-переменная видна только внутри блока, но сохраняет значение между вызовами функции. - Глобальный объект определяется вне всех функций и может использоваться несколькими функциями.
- Локальная переменная с тем же именем скрывает глобальный объект внутри своего блока.
-
Динамическая память доступна через указатель и должна освобождаться функцией
free. -
externиспользуется для описания объекта, определённого в другом месте программы. - Определение выделяет память, описание только сообщает компилятору о существовании объекта.
Самопроверка перед переходом дальше
- Что произойдёт с обычной локальной переменной после выхода из функции?
- Чем локальная
static-переменная отличается от обычной локальной переменной? - Почему переменная из примера с
static int kвыводит1 2 3 4 5, а не пять раз1? - Что такое глобальный объект?
- Почему глобальные переменные могут усложнять программу?
- Что означает «локальная переменная затенила глобальную»?
- Почему нельзя возвращать адрес обычной локальной переменной из функции?
- Что делает функция
malloc? - Зачем после работы с динамической памятью вызывать
free? - Чем описание
extern int x;отличается от определенияint x;?