Почему компилятор (IAR) не выдает ошибки в случае если переменная определена как глобальная в 2-х файлах с одним и тем же именем, а в третьем объявлена как extern? На какую из 2-х глобальных переменных в итоге она (объявленная как extern) будет ссылаться?

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

Если программа на С (не С++ !) и переменная в обоих файлах не инициализированна, то она может быть объявленна хоть в 10 файлах. Фича такая в С. Линкер сделает одну переменную на все файлы

Объявлена (с extern) она может быть сколько угодно раз, а определена (без extern и без static) может быть только в одном, что в С, что в С++.

да. На простом Си. Не инициализирована.
Забавно. Т.е. даже не использую extern эта переменная будет одна на все модули? как-то опасно. Или единожды где-то указать extern все таки надо?

Ну ситуация в общем такая. Объявлена глобально переменная в разных модулях с одним и тем же именем. Понятно, что это 2 разные глобальные переменные в разных модулях. Только имя одно. Но в третьем я ее записал как extern. Вот на какую из них ссылается extern?

ммм... извиняюсь за вопрос. все таки ошибка линкера есть. просто у меня другие ошибки были и до этой не дошло.

Сейчас попробовал объявить глобальные переменные с одинаковыми именами в 2-х модулях и линкер тоже сообщает об ошибках. Разве не должно быть, чтобы переменные хоть и с одним именем, но в итоге должны быть разные?

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

Нет, в С может много раз (хотя лучше так не делать) -

test1.c


test2.c


test3.c




А вот если переменные будут инициализированны, тогда ой!





Нет, линкер сольет их в одну

Обратите внимание на '*COM*' (и тип O) у переменной 'c' - это COMMON секция. Линкер выберет одну (произвольно) такую секцию из всех входных файлов и замкнет все ссылки на нее

хм... а ИАР мне так не разрешает. Объявления без инициализации, присвоение внутри функций. И все равно ругается. Может gcc немного по другому делает?

хм, заинтриговали, у меня IAR'овский линкер на такое пишет:
Error[e27]: Entry "c" in module 1 ( D:\Work\avrtest\Debug\Obj\1.r79 ) redefined in module 2 ( D:\Work\avrtest\Debug\Obj\2.r79 )

кто из них не торт?

а так у меня

Error[Li006]: duplicate definitions for "c"; in "C:\Users\Ñàøà\Desktop\Íîâàÿ ïàïêà (4)\Debug\Obj\test1.o", and "C:\Users\Ñàøà\Desktop\Íîâàÿ ïàïêà (4)\Debug\Obj\test2.o"

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

Понятно Спасибо за разъяснения. Почему то всегда считал, что глобальные переменные можно называть одинаково в разных модулях и без static. Но, вполне логично, тогда бы и возник вопрос куда ссылается extern если много одинаково именованых глобальных переменных. А так все четко. Не называй одинаково и все ОК

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

И если компилятор это поддерживает (как gcc), то лучше это ему запретить (если есть такая возможность)

Нет, это "чудесное" свойство компилятора, который вы используете, но никак не языка C.

Я использовал gcc (один из самых распростаненных компиляторов). Но вынужден вас разочаровать - это свойство именно языка С.

Стандарт С (99), глава 6.6.6: Linkages of identifiers
Так что для С слово extern и его отсуствие - одно и тоже

в том числе, по вкусу:
максимально об-static-овать все переменные, которые не нужны за пределами модуля
не лениться давать префиксы с именем модуля для глобальных
просто поменьше глобальных (C++ static-переменные класса с доступом через inline-методы рулят)

Вот...
Позволю себе немного дополнить. Правда, у меня другая нумерация, 6.2.2 (ISO/IEC 9899:1999 (E), слова draft нет, но нет и титульных страниц, надо бы обменяться файлами )
Нажмите для просмотра прикрепленного файла

Выделенное в цитатах из стандарта у XVR звучит как то, что объявления переменной в

описывают один объект с именем ii (и gcc так и считает).
Т.е. тут даже инициализация есть, но одна. Это полетит в .data, и если в другом файле тоже будет ii, то это будет конфликт (инициализация уже выступает не просто как объявление, но и как определение объекта). Похоже на работу с функцией — прототип можно указать в куче мест, но тело — в одном.
А вот если убрать инициализацию, то оно идёт не в .data, а в .comm с именем переменной. Чтобы в .bss, нужен ключ -fno-common и тогда линкер выругается.

Мне тут не нравится только то, что проверка размеров не производится, если в одном файле int c; а в другом long c;, то линкер даже не заметит. Не его проблема. Очень напоминает COMMON-блоки фортрана :-)
А так — «фича». Несколько непривычно, но вон после ассемблера и integer promotion непривычно.
На проблемы с этим никогда не нарывался, возможно, в силу простой внимательности и простым правилам, которіе я напсиал в начале. В итоге даже ключик нигде не стоит и пришлось полезть глянуть, как он точно звучит (помню, что есть, забыл какой).

Попытался перевести и понять, что там написано.
П. 5 описывает функции, там другие правила.
Единственное, что подходит - Each declaration of an identifier with no linkage denotes a unique entity.
Но разве из этого следует, что эти уникальные объекты останутся уникальными, если они определены в разных файлах одной программы?
Вот добавляем мы квалификатор static к определению переменной, чтобы ограничить ее видимость в пределах файла. Значит, без static она видна везде? Как же разруливать 2 одинаковых переменных?

Где-то там, в п.6.2.2 стандарта есть фраза, что если не указано иное, то "по-умолчанию" - extern. T.е указан extern явно, или не указано ничего, то это тоже extern, а значит - один и тот же объект.

По умолчанию в Си переменные имеют внешнее связывание, в Си++ -- внутреннее.

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

Что можно перевести как 'в наборе единиц компиляции и библиотек, который является всей программой'

Во 2м предложении оттуда речь идет уже о переменных (я немного не то предложение выделил)

Да
Их объединит линкер (если они обе не инициализированные), или получите слом на линковке

Константы, вы хотели сказать?

Нет, переменные. И функции тоже. Про константы утверждать не буду, но скорее всего, тоже.

ключевое слово const ( а также typedef ) дает имени внутреннее связывание.

при использовании имен без headers, например, в файле 1.с

const int a = 5;
то a имеет внутреннее связывание.

для того, чтобы а имела внешнее связывание, нужно

в файле 1.с

объявить a как extern;


и определить переменную:


теперь, для использования a в других единицах трансляции нужно просто объявить переменную

файл 2.с:




тоже самое достигается путем headera

теперь,
если же мы определяем в header что-то типа:

const int b = 10;

и включаем это header в различные единицы трансляции,
то в каждой единице трансляции создается своя локальная копия b

XVR,
а мне помнится, что во исходном файле глобальная переменная объявляется как обычном, а во всех остальных со спецификатором extern. где-то валялась книжка по стандарту C99.
Да и gcc для авр не позволял делать так, как вы описали.

И это правильно
Но стандарт не запрещает написать переменную многократно и без extern (IMHO из соображений совместимости - во времена K&R это была обычная практика)

А x86 позволил