Особенности использования extern и static в C/C++

Интенсивно занимаясь программированием на Си для AVR, в сети приходится искать некоторую информацию. Так получилось и на этот раз. Не помню, что я искал, но натолкнулся на один интересный комментарий на RSDN. К моей теме он не имел никакого отношения, да и к AVR, впринципе, тоже. Там на русском языке нормально описывалось применение модификаторов extern и static в C/C++. Ну уж очень хорошо написано. Толково и доходчиво. Поэтому я не мог пройти мимо и утащил к себе на сайт (как Плюшкин, блин), что б перед глазами было, что б не городить в браузере туеву хучу закладок, в которых потом теряешься. Может и еще кому интересно будет, пригодится. Вроде бы ссылки там в тексте были на стандарт С++, но он на английском, а здесь все на великом и могучем.  Итак…

[stextbox id=»grey»]Межмодульное взаимодействие[/stextbox]

Как указано в стандарте (см. п.п. 3.2/1), единица трансляции не должна содержать более одного определения любой переменной, функции, класса, перечисления и шаблона (в каждой области видимости, естественно). Это — так называемое правило одного определения (One-Definition Rule, ODR). В первую очередь это правило касается определений классов, переменных и функций. Для переменной компилятор по ее определению вычисляет размер и резервирует место в памяти, поэтому при наличии более одного определения в одной области видимости у него «возникают проблемы». Для класса компилятор тоже вычисляет размер, хотя обычно и не резервирует место в памяти — это делается при объявлении объектов класса.

[stextbox id=»warning» caption=»Примечание»]Для статических полей класса память резервируется до первого объявления объекта класса — при определении статического поля.[/stextbox]

Для функции компилятор генерирует код, который, в конечном счете, тоже займет свое место в памяти.
А вот объявлений может быть несколько. Объявление лишь добавляет некоторое имя в данную область видимости и обычно используется для согласования типов. Однако при разделении программы на отдельные модули возникают вопросы о взаимодействии определений и объявлений, прописанных в разных модулях. Естественно, речь не идет о локальных объектах — с ними все ясно.

Межмодульные переменные и функции

Начнем с простых переменных. Допустим, у нас есть два модуля A.cpp и B.cpp. В модуле A определена целая переменная i вне всех классов и функций:

int i = 2;

Такая переменная называется глобальной. В файле A она видна от точки определения и до конца файла. Однако в модуле B эта переменная не видна. И если вдруг нам потребуется в модуле B присвоить ей другое значение, у нас возникнут некоторые проблемы. Нельзя просто написать:

i = 1;

В этом случае компилятор при обработке модуля B «не видит» модуль A и ничего не знает об определенной там переменной, поэтому мы получим сообщение о неопределенной переменной. Также нельзя написать:

int i = 1;

Такая запись является повторным определением. Компилятор-то «возражать» не станет — он транслирует модули по отдельности, а вот компоновщик будет «воротить нос» и сообщит, что одна и та же переменная определена дважды. Для таких случаев в С++ включено специальное ключевое слово extern. В модуле B надо объявить переменную следующим образом:

extern int i;

После этого можно использовать переменную i в файле B любым разрешенным способом. Например, присвоить новое значение:

i = 1;

Однако попытка совместить объявление с присвоением значения является ошибкой:

extern int i = 1;

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

[stextbox id=»warning» caption=»Примечание»]Хотя ключевое слово extern в стандарте определено как один из четырех классов хранения, проще понимать его как обозначение «внешнего» имени для данного модуля. Имя называется внешним по отношению к модулю, если объект с этим именем не определен в данном модуле.[/stextbox]

Аналогичная картина наблюдается и с функциями. Определение функции включает тело, а объявлением является прототип. Пусть в модуле A определена функция:

void f(void)
{ cout << "f()" << endl; }

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

void f(void);

Слова extern писать не требуется, хотя и не запрещается. Следующие прототипы эквивалентны:

void f(void);
extern void f(void);

Локализация имен в модуле

Итак, определив глобальную переменную или функцию в некоторой единице трансляции, мы должны придерживаться определенных правил, чтобы не возникало конфликтов имен. Говорят, что для имен глобальных переменных и функций применяется внешняя компоновка (extenal linkage), то есть эти имена становятся видны компоновщику во время компоновки программы.

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

static int a = 1;
static void f(void) { ... }

Для определенных таким образом имен применяется внутренняя компоновка (internal linkage) — они являются локальными в модуле, где определены. Таким образом, можно говорить, что глобальные имена обладают свойством внешней или внутренней компоновки.

Разберемся с некоторыми подробностями на примере функций. Пусть у нас есть, как обычно, два модуля A.cpp и B.cpp:

//--модуль A.cpp
void f1(void) {...}; // определение глобальной функции
static void f2(void){...}; // определение локальной функции
//--модуль B.cpp
f1(); // вызов глобальной функции
f2(); // ОШИБКА!! -- вызов невидимой функции

Функция f2() не видна в модуле B, поэтому ее вызов ведет к ошибке трансляции.

Имя функции с атрибутом static должно быть уникальным в данном модуле, но может повторяться в других модулях. Более того, локальная в модуле функция (с атрибутом static) перекрывает глобальную функцию в пределах модуля (аналогично тому, как локальная переменная в теле функции перекрывает глобальную). Например, в следующем примере функция f1() в модуле B.cpp перекрывает глобальную функцию, определенную в модуле A.cpp.

//--модуль A.cpp
void f1(void) {...}; // определение глобальной функции
static void f2(void){...}; // определение локальной функции
f1(); // вызов глобальной функции
//--модуль B.cpp
static void f1(void) {...}; // определение локальной функции
f1(); // вызов локальной функции

Все то же самое относится и к глобальным переменным с атрибутом static.

Атрибут static в данном случае похож на модификатор доступа private, работающий на уровне файла. Налицо два совершенно разных смысла одного ключевого слова: с одной стороны, для локальных переменных static означает класс хранения (в статической памяти); с другой стороны, на уровне модуля атрибут static имеет смысл ограничителя видимости имен. Последнее объявлено устаревшим, поэтому применение атрибута static в таком значении является нежелательным (см. п. D2). Вместо этого для решения проблем локализации в С++ включили пространства имен, которые мы рассмотрим далее.

Константы по умолчанию компонуются внутренним образом. Это означает, что при объявлении константы нет необходимости указывать атрибут static, чтобы сделать ее локальной в модуле. Поэтому в разных модулях можно объявлять глобальные константы с одинаковыми именами — конфликта при компоновке не происходит. Более того, чтобы сделать константу, объявленную в одном модуле, видимой в другом, нужно использовать слово extern:

// модуль A.cpp
extern const int a = 2;
// модуль B.cpp
extern const int a;

Тогда компоновщик будет считать, что в модулях A.cpp и B.cpp используется одна и та же целая константа с именем a. Если мы пропустим слово extern в объявлении константы в модуле А.cpp, то получим локализованную константу, и при обработке объявления в модуле В.cpp компоновщик выдаст сообщение о неопределенном имени.

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

template
class Template { ... };
Template T; // Ошибка!

Нельзя использовать и глобальный указатель:

template
class Template { ... };
char const *s = "Literal";
Template < s > T; // Ошибка!

Однако глобальный символьный массив использовать можно:

template
class Template { ... };
char const s[] = "Literal";
Template < s > T; // Ошибки нет!

Для функций, объявленных как подставляемые (с ключевым словом inline), по умолчанию тоже применяется внутренняя компоновка. Функция, определенная в одном модуле, не видна в другом модуле. Даже если определения в модулях абсолютно синтаксически совпадают — это все-таки могут быть разные функции, например:

// модуль A.cpp
const int a = 7;
inline void f(void)
{ cout << a << "f()\n"; }
// модуль B.cpp
const int a = 10;
inline void f(void)
{ cout << a << "f()\n"; }

При вызове первой функции в модуле А получим на экране 7f(), а при вызове второй в модуле В на экране появится 10f().

Так же как и определение класса, определение подставляемой функции может быть включено в программу несколько раз — по одному определению в каждом модуле. Чтобы гарантированно иметь в разных модулях одно и то же определение, мы вынесем его в отдельный модуль и подключим этот модуль в нужных файлах с помощью директивы #include — компоновщик против не будет. Естественно, определение не должно зависеть от локализованных имен, как в приведенном ранее примере.

Можно сделать подставляемую функцию глобальной — точно так же, как и константу, указав в определении ключевое слово extern:

// модуль A.cpp
// Определение глобальной inline-функции
extern inline void f(void)
{ cout << a << "f()\n"; }

В другом модуле достаточно указать прототип:

// модуль B.cpp
// объявление внешней inline-функции
void f(void);

К прототипу можно добавить спецификаторы extern и inline:

extern inline void f(void);

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

Вот такой интересный комментарий. Все разложено по полочкам. Надеюсь вам пригодилось.