Объявления переменных в файлах заголовков - статические или нет?

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

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

Примечание редактора: В C ++ объекты const без ключевых слов static и extern в своем объявлении неявно являются static.

Теги static и extern в переменных уровня файла определяют, доступны ли они в других единицах перевода (т. Е. В других файлах .c или .cpp).

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

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

Значение по умолчанию (если вы не указали static или extern) - это одна из тех областей, в которых C и C ++ различаются.

• В языке C переменные области видимости файла по умолчанию равны extern (внешняя связь). Если вы используете C, VAL это static, а ANOTHER_VAL extern.

• В C ++ переменные области видимости файла - это static (внутренняя связь) по умолчанию, если они равны const, и extern по умолчанию, если это не так. Если вы используете C ++, оба VAL и ANOTHER_VAL равны static.

Из черновика спецификации C:

6.2.2 Связи идентификаторов ... -5- Если объявление идентификатора для функции не имеет спецификатора класса хранения, его связь определяется точно так, как если бы оно было объявлено с помощью спецификатора класса хранения extern. Если объявление идентификатора для объекта имеет область действия файла и не имеет спецификатора класса хранения, его связь является внешней.

Из черновика спецификации C ++:

7.1.1 - Спецификаторы класса хранилища [dcl.stc] ... -6- Имя, объявленное в области пространства имен без спецификатора класса-хранилища, имеет внешнюю связь, если только оно не имеет внутренней связи из-за предыдущего объявления и при условии, что это не так. объявлен const. Объекты, объявленные как const и явно не объявленные как extern, имеют внутреннюю связь.

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

test.h:

static int TEST = 0;
void test();

test1.cpp:

#include <iostream>
#include "test.h"

int main(void) {
    std::cout << &TEST << std::endl;
    test();
}

test2.cpp:

#include <iostream>
#include "test.h"

void test() {
    std::cout << &TEST << std::endl;
}

Выполнение этого дает вам следующий результат:

0x446020
0x446040

const переменные в C ++ имеют внутреннюю связь. Таким образом, использование static не имеет никакого эффекта.

а.ч

const int i = 10;

one.cpp

#include "a.h"

func()
{
   cout << i;
}

two.cpp

#include "a.h"

func1()
{
   cout << i;
}

Если бы это была программа на C, вы бы получили ошибку «множественное определение» для i (из-за внешней связи).

Статическое объявление на этом уровне кода означает, что переменная видна только в текущей единице компиляции. Это означает, что только код в этом модуле увидит эту переменную.

если у вас есть файл заголовка, в котором объявлена ​​статическая переменная, и этот заголовок включен в несколько файлов C / CPP, тогда эта переменная будет «локальной» для этих модулей. Будет N копий этой переменной для N мест, в которые включен заголовок. Они никак не связаны друг с другом. Любой код в любом из этих исходных файлов будет ссылаться только на переменную, объявленную в этом модуле.

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

Что касается встраивания, то в этом случае переменная, скорее всего, встроена, но только потому, что она объявлена ​​как const. Компилятор может с большей вероятностью встроить статические переменные модуля, но это зависит от ситуации и компилируемого кода. Нет никакой гарантии, что компилятор встроит «статику».

В книге C (бесплатно в Интернете) есть глава о связывании, в которой более подробно объясняется значение слова «статика» (хотя правильный ответ уже дан в других комментариях): http://publications.gbdirect.co.uk/c_book/chapter4/linkage.html

Чтобы ответить на вопрос, "статика означает, что создается только одна копия VAL, если заголовок включен более чем одним исходным файлом?" ...

НЕТ. VAL всегда будет определяться отдельно в каждом файле, который включает заголовок.

В этом случае стандарты для C и C ++ действительно вызывают разницу.

В C переменные файловой области по умолчанию являются внешними. Если вы используете C, VAL статичен, а ANOTHER_VAL - extern.

Обратите внимание, что современные компоновщики могут жаловаться на ANOTHER_VAL, если заголовок включен в разные файлы (одно и то же глобальное имя определено дважды), и определенно будут жаловаться, если ANOTHER_VAL был инициализирован другим значением в другом файле.

В C ++ переменные с файловой областью по умолчанию являются статическими, если они являются константами, и extern по умолчанию, если они не являются. Если вы используете C ++, и VAL, и ANOTHER_VAL статичны.

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

• параметры отладки
• адрес взят из файла
• компилятор всегда выделяет память (сложные константные типы не могут быть легко встроены, поэтому становится особым случаем для базовых типов)

Предполагая, что эти объявления находятся в глобальной области (т.е. не являются переменными-членами), тогда:

статический означает «внутренняя связь». В этом случае, поскольку он объявлен как const, он может быть оптимизирован / встроен компилятором. Если вы опустите const, компилятор должен выделить память в каждой единице компиляции.

Если опустить статические, по умолчанию будет установлено значение extern. Опять же, вас спасла const ness - компилятор может оптимизировать / встроить использование. Если вы опустите const, вы получите ошибку множественно определенных символов во время связывания.

Вы не можете объявить статическую переменную без ее определения (это потому, что модификаторы класса хранения static и extern являются взаимоисключающими). Статическая переменная может быть определена в файле заголовка, но это приведет к тому, что каждый исходный файл, включающий файл заголовка, будет иметь свою собственную частную копию переменной, что, вероятно, не то, что планировалось.

Переменные const по умолчанию статические в C ++, но extern C. Поэтому, если вы используете C ++, не имеет смысла, какую конструкцию использовать.

(7.11.6 C ++ 2003, и в Apexndix C есть образцы)

Пример сравнения источников компиляции / ссылки как программы C и C ++:

bruziuz:~/test$ cat a.c
const int b = 22;
int main(){return 0;}
bruziuz:~/test$ cat b.c
const int b=2;
bruziuz:~/test$ gcc -x c -std=c89 a.c b.c
/tmp/ccSKKIRZ.o:(.rodata+0x0): multiple definition of `b'
/tmp/ccDSd0V3.o:(.rodata+0x0): first defined here
collect2: error: ld returned 1 exit status
bruziuz:~/test$ gcc -x c++ -std=c++03 a.c b.c 
bruziuz:~/test$ 
bruziuz:~/test$ gcc --version | head -n1
gcc (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609

Статический не позволяет другому модулю компиляции извлекать эту переменную, так что компилятор может просто «встроить» значение переменной в то место, где оно используется, и не создавать для него хранилище памяти.

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

Статический не позволяет компилятору добавлять несколько экземпляров. Это становится менее важным с защитой #ifndef, но при условии, что заголовок включен в две отдельные библиотеки, а приложение связано, будут включены два экземпляра.