Как указано в стандарте (см. п.п. 3.2/1 в [1]), единица трансляции не должна содержать более одного определения любой переменной, функции, класса, перечисления и шаблона (в каждой области видимости, естественно). Это — так называемое правило одного определения (One-Definition Rule, ODR). В первую очередь это правило касается определений классов, переменных и функций. Для переменной компилятор по ее определению вычисляет размер и резервирует место в памяти, поэтому при наличии более одного определения в одной области видимости у него «возникают проблемы». Для класса компилятор тоже вычисляет размер, хотя обычно и не резервирует место в памяти — это делается при объявлении объектов класса.
ПРИМЕЧАНИЕ
Для статических полей класса память резервируется до первого объявления объекта класса — при определении статического поля.
Для функции компилятор генерирует код, который, в конечном счете, тоже займет свое место в памяти.
А вот объявлений может быть несколько. Объявление лишь добавляет некоторое имя в данную область видимости и обычно используется для согласования типов. Однако при разделении программы на отдельные модули возникают вопросы о взаимодействии определений и объявлений, прописанных в разных модулях. Естественно, речь не идет о локальных объектах — с ними все ясно.
Межмодульные переменные и функции
Начнем с простых переменных. Допустим, у нас есть два модуля A.cpp и B.cpp. В модуле A определена целая переменная i вне всех классов и функций:
Такая переменная называется глобальной. В файле A она видна от точки определения и до конца файла. Однако в модуле B эта переменная не видна. И если вдруг нам потребуется в модуле B присвоить ей другое значение, у нас возникнут некоторые проблемы. Нельзя просто написать:
В этом случае компилятор при обработке модуля B «не видит» модуль A и ничего не знает об определенной там переменной, поэтому мы получим сообщение о неопределенной переменной. Также нельзя написать:
Такая запись является повторным определением. Компилятор-то «возражать» не станет — он транслирует модули по отдельности, а вот компоновщик будет «воротить нос» и сообщит, что одна и та же переменная определена дважды. Для таких случаев в С++ включено специальное ключевое слово extern. В модуле B надо объявить переменную следующим образом:
После этого можно использовать переменную i в файле B любым разрешенным способом. Например, присвоить новое значение:
Однако попытка совместить объявление с присвоением значения является ошибкой:
Такая запись служит определением, поэтому мы опять получим от компоновщика сообщение о повторном определении.
ПРИМЕЧАНИЕ
Хотя ключевое слово extern в стандарте определено как один из четырех классов хранения, проще понимать его как обозначение «внешнего» имени для данного модуля. Имя называется внешним по отношению к модулю, если объект с этим именем не определен в данном модуле.
Аналогичная картина наблюдается и с функциями. Определение функции включает тело, а объявлением является прототип. Пусть в модуле A определена функция:
| C++ |
1
2
| void f(void)
{ cout << "f()" << endl; } |
|
Для того чтобы эту функцию можно было использовать в модуле B, нужно объявить там ее прототип:
Слова extern писать не требуется, хотя и не запрещается. Следующие прототипы эквивалентны:
| C++ |
1
2
| void f(void);
extern void f(void); |
|
Итак, определив глобальную переменную или функцию в некоторой единице трансляции, мы должны придерживаться определенных правил, чтобы не возникало конфликтов имен. Говорят, что для имен глобальных переменных и функций применяется внешняя компоновка (extenal linkage), то есть эти имена становятся видны компоновщику во время компоновки программы.
Однако иногда бывает нужно, чтобы глобальная переменная или функция были видны только в том файле, где определены. Это позволяет сделать атрибут static, например:
| C++ |
1
2
| static int a = 1;
static void f(void) { ... } |
|
Для определенных таким образом имен применяется внутренняя компоновка (internal linkage) — они являются локальными в модуле, где определены. Таким образом, можно говорить, что глобальные имена обладают свойством внешней или внутренней компоновки.
Разберемся с некоторыми подробностями на примере функций. Пусть у нас есть, как обычно, два модуля A.cpp и B.cpp:
| C++ |
1
2
3
4
5
6
| //--модуль A.cpp
void f1(void) {...}; // определение глобальной функции
static void f2(void){...}; // определение локальной функции
//--модуль B.cpp
f1(); // вызов глобальной функции
f2(); // ОШИБКА!! -- вызов невидимой функции |
|
Функция f2() не видна в модуле B, поэтому ее вызов ведет к ошибке трансляции.
Имя функции с атрибутом static должно быть уникальным в данном модуле, но может повторяться в других модулях. Более того, локальная в модуле функция (с атрибутом static) перекрывает глобальную функцию в пределах модуля (аналогично тому, как локальная переменная в теле функции перекрывает глобальную). Например, в следующем примере функция f1() в модуле B.cpp перекрывает глобальную функцию, определенную в модуле A.cpp.
| C++ |
1
2
3
4
5
6
7
| //--модуль A.cpp
void f1(void) {...}; // определение глобальной функции
static void f2(void){...}; // определение локальной функции
f1(); // вызов глобальной функции
//--модуль B.cpp
static void f1(void) {...}; // определение локальной функции
f1(); // вызов локальной функции |
|
Все то же самое относится и к глобальным переменным с атрибутом static.
Атрибут static в данном случае похож на модификатор доступа private, работающий на уровне файла. Налицо два совершенно разных смысла одного ключевого слова: с одной стороны, для локальных переменных static означает класс хранения (в статической памяти); с другой стороны, на уровне модуля атрибут static имеет смысл ограничителя видимости имен. Последнее объявлено устаревшим, поэтому применение атрибута static в таком значении является нежелательным (см. п. D2 в [1]). Вместо этого для решения проблем локализации в С++ включили пространства имен, которые мы рассмотрим далее.
Константы по умолчанию компонуются внутренним образом. Это означает, что при объявлении константы нет необходимости указывать атрибут static, чтобы сделать ее локальной в модуле. Поэтому в разных модулях можно объявлять глобальные константы с одинаковыми именами — конфликта при компоновке не происходит. Более того, чтобы сделать константу, объявленную в одном модуле, видимой в другом, нужно использовать слово
extern:
| C++ |
1
2
3
4
| // модуль A.cpp
extern const int a = 2;
// модуль B.cpp
extern const int a; |
|
Тогда компоновщик будет считать, что в модулях A.cpp и B.cpp используется одна и та же целая константа с именем a. Если мы пропустим слово extern в объявлении константы в модуле А.cpp, то получим локализованную константу, и при обработке объявления в модуле В.cpp компоновщик выдаст сообщение о неопределенном имени.
Внутренняя компоновка констант оказывает «медвежью услугу» в шаблонах. Поскольку строковые литералы — это объекты со свойством внутренней компоновки, использовать их в качестве аргумента шаблона не разрешается:
| C++ |
1
2
3
4
5
6
7
8
| template<char const *str>
class Template { ... };
Template<"literal"> T; // Ошибка!
Нельзя использовать и глобальный указатель:
template<char const *str>
class Template { ... };
char const *s = "Literal";
Template<s> T; // Ошибка! |
|
Однако глобальный символьный массив использовать можно:
| C++ |
1
2
3
4
| template<char const *str>
class Template { ... };
char const s[] = "Literal";
Template<s> T; // Ошибки нет! |
|
Для функций, объявленных как подставляемые (с ключевым словом inline), по умолчанию тоже применяется внутренняя компоновка. Функция, определенная в одном модуле, не видна в другом модуле. Даже если определения в модулях абсолютно синтаксически совпадают — это все-таки могут быть разные функции, например:
| C++ |
1
2
3
4
5
6
7
8
| // модуль 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:
| C++ |
1
2
3
4
| // модуль A.cpp
// Определение глобальной inline-функции
extern inline void f(void)
{ cout << a << "f()\n"; } |
|
В другом модуле достаточно указать прототип:
| C++ |
1
2
3
| // модуль B.cpp
// объявление внешней inline-функции
void f(void); |
|
К прототипу можно добавить спецификаторы
extern и
inline:
| C++ |
1
| extern inline void f(void); |
|
Как видите, в этом случае можно обойтись без подключения модуля с определением.
[1] — это стандарт С++
(
Сообщение от SDmaN
