Как объявить глобальную переменную c в другом файле

Обновлено: 24.01.2025

Си - регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.

Типы переменных

1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).

Целые

char - размер 1 байт. Всегда! Это нужно запомнить.
short - размер 2 байта
int - размер 4 байта
long - размер 4 байта
long long - размер 8 байт.

char <= short <= int <= long <= long long

Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.

Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char - все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.

Таб. 1 Размер целых типов в си.

Тип	Размер, байт	Минимальное значение	Максимальное значение
unsigned char	1	0	255
signed char ( char )	1	-128	127
unsigned short	2	0	65535
signed short ( short )	2	-32768	32767
unsigned int ( unsigned )	4	0	4294967296
signed int ( int )	4	-2147483648	2147483647
unsigned long	4	0	4294967296
signed long ( long )	4	-2147483648	2147483647
unsigned long long	8	0	18446744073709551615
signed long long ( long long )	8	-9223372036854775808	9223372036854775807

sizeof

В си есть оператор, который позволяет получить размер переменной в байтах. sizeof переменная, или sizeof(переменная) или sizeof(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.

(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще

В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned

Типы с плавающей точкой

float - 4 байта,
long float - 8 байт
double - 8 байт
long double - 8 байт.

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы "сбросим значение"

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

Постфиксное обозначение типа

11 - число типа int
10u - unsigned
22l или 22L - long
3890ll или 3890LL - long long (а также lL или Ll)
80.0f или 80.f или 80.0F - float (обязательно наличие десятичной точки в записи)
3.0 - число типа double

Следующий код, однако, не будет приводить к ошибкам, потому что происходит неявное преобразование типа

Шестнадцатеричный и восьмеричный формат

В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:

Экспоненциальная форма представления чисел

Объявление переменных

В си переменные объявляются всегда в начале блока (блок - участок кода ,ограниченный фигурными скобками)

При объявлении переменной пишется её тип и имя.

Можно объявить несколько переменных одного типа, разделив имена запятой

Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции

Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать

Начальное значение переменной

О чень важно запомнить, что переменные в си не инициализируются по умолчанию нулями, как во многих других языках программирования. После объявления переменной в ней хранится "мусор" - случайное значение, которое осталось в той области памяти, которая была выделена под переменную. Это связано, в первую очередь, с оптимизацией работы программы: если нет необходимости в инициализации, то незачем тратить ресурсы для записи нулей (замечание: глобальные переменные инициализируются нулями, почему так, читайте в этой статье).

Область видимости переменной

П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная "видна в каком-то месте", это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная

Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример

Программа выведет 555. Также, как и в прошлом случае, локальная переменная "важнее". Переменная, объявленная в некоторой области видимости не видна вне её, например

Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга

Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое

1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
2) Работает в несколько потоков

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

Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.

Всё ещё не понятно? – пиши вопросы на ящик

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

Определение глобальных переменных

// Переменные, определенные вне блока, являются глобальными переменными const int g_y ( 3 ) ; // константная глобальная переменная g_y // Глобальные переменные можно использовать в любом месте программы // Глобальные переменные можно использовать в любом месте программы

Подобно тому, как переменные во внутреннем блоке скрывают переменные с теми же именами во внешнем блоке, локальные переменные скрывают глобальные переменные с одинаковыми именами внутри блока, в котором они определены. Однако с помощью оператора разрешения области видимости ( :: ), компилятору можно сообщить, какую версию переменной вы хотите использовать: глобальную или локальную. Например:

int value = 8 ; // эта переменная (локальная) скрывает значение глобальной переменной value ++ ; // увеличивается локальная переменная value (не глобальная) :: value -- ; // уменьшается глобальная переменная value (не локальная)

Результат выполнения программы:

Global value: 3
Local value: 9

Ключевые слова static и extern

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

Переменная без связей — это переменная с локальной областью видимости, которая относится только к блоку, в котором она определена. Это обычные локальные переменные. Две переменные с одинаковыми именами, но определенные в разных функциях, не имеют никакой связи — каждая из них считается независимой единицей.

Переменная, имеющая внешние связи, называется внешней переменной. Она может использоваться как в файле, в котором определена, так и в других файлах.

Если вы хотите сделать глобальную переменную внутренней (которую можно использовать только внутри одного файла) — используйте ключевое слово static:

Я знаю, что глобальные переменные в C иногда имеют ключевое слово extern . Что такое переменная extern ? Что такое декларация? Какова его область действия?

Это связано с обменом переменными в исходных файлах, но как это работает? Где я могу использовать extern ?

ОТВЕТЫ

Ответ 1

Использование extern имеет extern только в том случае, когда создаваемая вами программа состоит из нескольких исходных файлов, связанных друг с другом, где некоторые из переменных, определенных, например, в исходном файле file1.c должны быть указаны в других исходных файлах, таких как file2.c .

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

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

Лучший способ объявить и определить глобальные переменные

Чистый, надежный способ объявить и определить глобальные переменные - использовать заголовочный файл, чтобы содержать объявление extern переменной.

Заголовок включается одним исходным файлом, который определяет переменную и всеми исходными файлами, ссылающимися на переменную. Для каждой программы один параметр (и только один исходный файл) определяет переменную. Аналогично, один заголовочный файл (и только один заголовочный файл) должен объявить переменную. Файл заголовка имеет решающее значение; он позволяет осуществлять перекрестную проверку между независимыми TU (единицами перевода - исходными файлами) и обеспечивает согласованность.

Хотя есть и другие способы сделать это, этот метод прост и надежен. Это демонстрируется file3.h , file1.c и file2.c :

file3.h

file1.c

file2.c

Это лучший способ объявить и определить глобальные переменные.

Следующие два файла завершают источник для prog1 :

В приведенных программах показаны функции, поэтому в них вписались декларации функций. Оба C99 и C11 требуют, чтобы функции объявлялись или определялись до их использования (в то время как C90 по уважительным причинам). Я использую ключевое слово extern перед декларациями функций в заголовках для согласованности - для соответствия extern перед объявлениями переменных в заголовках. Многие люди предпочитают не использовать extern перед декларациями функций; компилятору все равно - и в конечном итоге, я не до тех пор, пока вы согласны, по крайней мере, в исходном файле.

prog1.h

prog1.c

prog1 использует prog1.c , file1.c , file2.c , file3.h и prog1.h .

Файл prog1.mk является make- prog1 только для prog1 . Она будет работать с большинством версий make производства, так как о рубеже тысячелетий. Он не привязан специально к GNU Make.

prog1.mk

Методические рекомендации

Правила должны быть нарушены только экспертами и только с полным основанием:

Заголовочный файл содержит только объявления extern переменных - никогда не static или неквалифицированные определения переменных.
Для любой данной переменной объявляется только один файл заголовка (SPOT - Single Point of Truth).
Исходный файл никогда не содержит extern деклараций переменных - исходные файлы всегда включают заголовок (единственный), который их объявляет.
Для любой заданной переменной ровно один исходный файл определяет переменную, предпочтительно инициализируя ее. (Хотя нет необходимости явно инициализировать нуль, это не наносит вреда и может принести пользу, потому что в программе может быть только одно инициализированное определение конкретной глобальной переменной).
Исходный файл, который определяет переменную, также включает заголовок, чтобы гарантировать, что определение и декларация согласованы.
Функция никогда не должна объявлять переменную с использованием extern .
Избегайте глобальных переменных, когда это возможно, вместо этого используйте функции.

Исходный код и текст этого ответа доступны в моем репозитории SOQ (Qaru Questions) в GitHub в подкаталоге src/so-0143-3204.

Если вы не опытный программист на C, вы можете (и, возможно, должны) перестать читать здесь.

Не так хороший способ определить глобальные переменные

С некоторыми (действительно, многими) компиляторами C вы можете избавиться от так называемого "общего" определения переменной. "Common" здесь относится к методу, используемому в Fortran для обмена переменными между исходными файлами, используя (возможно, называемый) COMMON-блок. Что здесь происходит, так это то, что каждый из нескольких файлов содержит предварительное определение переменной. Если не более одного файла предоставляет инициализированное определение, то различные файлы в конечном итоге используют общее одно определение переменной:

file10.c

file11.c

file12.c

Этот метод не соответствует букве стандарта C и "одному правилу определения" - это официально неопределенное поведение:

J.2 Неопределенное поведение

Идентификатор с внешней связью используется, но в программе не существует только одного внешнего определения для идентификатора, или идентификатор не используется, и существует множество внешних определений для идентификатора (6.9).

§6.9 Внешние определения ¶5

Внешнее определение - это внешнее объявление, которое также является определением функции (отличной от встроенного определения) или объекта. Если идентификатор, объявленный с внешней связью, используется в выражении (кроме как в части операнда оператора sizeof или _Alignof , результат которого является целочисленной константой), где-то во всей программе должно быть ровно одно внешнее определение для идентификатора; в противном случае должно быть не более одного. 161)

161) Таким образом, если идентификатор, объявленный с внешней связью, не используется в выражении, для него не должно быть внешнего определения.

Однако стандарт C также перечисляет его в информационном приложении J как одно из общих расширений.

J.5.11 Множество внешних определений

Для идентификатора объекта может быть несколько внешних определений с явным использованием ключевого слова extern; если определения не согласуются или более одного инициализируется, поведение не определено (6.9.2).

Поскольку этот метод не всегда поддерживается, лучше избегать его использования, особенно если ваш код должен быть портативным. Используя эту технику, вы также можете столкнуться с непреднамеренным тиражом. Если один из файлов объявил i как double , а не как int , C типа небезопасных линкеры, вероятно, не заметят несоответствие. Если вы находитесь на машине с 64-битным int и double , вы даже не получите предупреждение; на машине с 32-битным int и 64-битным double , вы, вероятно, получите предупреждение о разных размерах - компоновщик будет использовать самый большой размер, точно так же, как программа Fortran займет наибольший размер любых общих блоков.

Следующие два файла завершают источник для prog2 :

prog2.h

prog2.c

prog2 использует prog2.c , file10.c , file11.c , file12.c , prog2.h .

Предупреждение

Как отмечено в комментариях здесь, и, как указано в моем ответе на аналогичный вопрос, использование нескольких определений для глобальной переменной приводит к неопределенному поведению (J.2, §6.9), что является стандартным способом сказать "что-нибудь может случиться". Одна из вещей, которая может случиться, заключается в том, что программа ведет себя так, как вы ожидаете; и J.5.11 говорит примерно так: "вам может повезти чаще, чем вы этого заслуживаете". Но программа, которая опирается на несколько определений внешней переменной - с или без явного ключевого слова "extern" - не является строго соответствующей программой и не гарантируется работать повсюду. Эквивалентно: в нем содержится ошибка, которая может показаться или не отображаться.

Нарушение правил

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

faulty_header.h

Примечание 1: если заголовок определяет переменную без ключевого слова extern , то каждый файл, содержащий заголовок, создает предварительное определение переменной. Как отмечалось ранее, это часто будет работать, но стандарт C не гарантирует, что он будет работать.

broken_header.h

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

seldom_correct.h

Примечание 3: если заголовок определяет статическую переменную (с инициализацией или без нее), то каждый исходный файл заканчивается своей частной версией "глобальной" переменной.

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

Резюме

Сначала используйте технику заголовка, которую я показал. Он работает надежно и везде. Обратите внимание, в частности, что заголовок, объявляющий global_variable , включен в каждый используемый файл - в том числе тот, который его определяет. Это гарантирует, что все самосогласовано.

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

Конец оригинального ответа

Если вы не опытный программист на C, вы, вероятно, должны перестать читать здесь.

Позднее значительное дополнение

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

Еще одна проблема может заключаться в том, что переменные должны быть определены в каждом из нескольких "основных программ". Обычно это ложная забота; вы можете просто ввести исходный файл C, чтобы определить переменные и связать файл объекта, созданный с каждой из программ.

Типичная схема работает так, используя исходную глобальную переменную, показанную в file3.h :

file3a.h

file1a.c

file2a.c

Следующие два файла завершают источник для prog3 :

prog3.h

prog3.c

prog3 использует prog3.c , file1a.c , file2a.c , file3a.h , prog3.h .

Инициализация переменных

Проблема с этой схемой, как показано, заключается в том, что она не предусматривает инициализацию глобальной переменной. С C99 или C11 и списками переменных аргументов для макросов вы также можете определить макрос для поддержки инициализации. (С C89 и без поддержки списков переменных аргументов в макросах нет простого способа обработки условно длинных инициализаторов.)

file3b.h

file1b.c

file2b.c

Очевидно, что код для структуры oddball - это не то, что вы обычно пишете, но это иллюстрирует суть. Первым аргументом второго вызова INITIALIZER является < 41 а оставшийся аргумент (единственный в этом примере) равен 43 >. Без C99 или аналогичной поддержки для списков переменных аргументов для макросов, инициализаторы, которые должны содержать запятые, очень проблематичны.

Исправлен заголовок file3b.h (вместо fileba.h ) за Дениса Княжева

Следующие два файла завершают источник для prog4 :

prog4.h

prog4.c

prog4 использует prog4.c , file1b.c , file2b.c , prog4.h , file3b.h .

Заголовки

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

Заголовок может быть включен дважды косвенно. Например, если file4b.h включает file3b.h для определения типа, которое не показано, а file1b.c должно использовать оба file4b.h и file3b.h , тогда у вас есть еще более сложные проблемы. Очевидно, вы можете пересмотреть заголовок, чтобы включить только file4b.h . Однако вы можете не знать о внутренних зависимостях, и в идеале код должен, в идеале, продолжать работать.

Кроме того, он начинает становиться сложным, потому что вы можете включить file4b.h прежде чем включать file3b.h для генерации определений, но обычные file3b.h заголовков на file3b.h будут препятствовать повторному включению заголовка.

Таким образом, вам нужно включить тело file3b.h не более одного раза для деклараций и не более одного раза для определений, но вам может понадобиться как одна единица перевода (TU - комбинация исходного файла и используемых заголовков),

Множественное включение с определениями переменных

Однако это может быть сделано с учетом не слишком необоснованного ограничения. Введем новый набор имен файлов:

external.h для макросов EXTERN и т.д.
file1c.h чтобы определить типы (в частности, struct oddball , тип oddball_struct ).
file2c.h чтобы определить или объявить глобальные переменные.
file3c.c который определяет глобальные переменные.
file4c.c который просто использует глобальные переменные.
file5c.c который показывает, что вы можете объявить, а затем определить глобальные переменные.
file6c.c который показывает, что вы можете определить и затем (попытаться) объявить глобальные переменные.

В этих примерах file5c.c и file6c.c несколько раз включают заголовок file2c.h несколько раз, но это самый простой способ показать, что механизм работает. Это означает, что если заголовок косвенно включался дважды, это также было бы безопасно.

В уроке «6.3 – Локальные переменные» мы рассмотрели, что локальные переменные – это переменные, определенные внутри функции (или параметры функции). Локальные переменные имеют область видимости блока (видны только внутри блока, в котором они объявлены) и имеют автоматическую продолжительность (они создаются в точке определения и уничтожаются при выходе из блока).

В C++ переменные также могут быть объявлены вне функции. Такие переменные называются глобальными переменными.

Объявление и именование глобальных переменных

По соглашению глобальные переменные объявляются в верхней части файла, ниже включений заголовочных файлов, но выше любого кода. Ниже показан пример определения глобальной переменной:

Приведенный выше пример напечатает:

По соглашению многие разработчики добавляют к идентификаторам глобальных переменных префикс " g " или " g_ ", чтобы указать, что они глобальные.

Лучшая практика

Рассмотрите возможность использования префикса " g " или " g_ " для глобальных переменных, чтобы помочь отличить их от локальных переменных.

Глобальные переменные имеют область видимости файла и статическую продолжительность

Глобальные переменные имеют область видимости файла (также неофициально называемую глобальной областью видимости или областью видимости глобального пространства имен), что означает, что они видны с момента объявления до конца файла, в котором они объявлены. С момента объявления глобальную переменную можно использовать в любом месте файла! В приведенном выше примере глобальная переменная g_x используется в обеих функциях doSomething() и main() .

Поскольку они определяются вне функции, глобальные переменные считаются частью глобального пространства имен (отсюда и термин «область видимости глобального пространства имен»).

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

В отличие от локальных переменных, которые по умолчанию не инициализируются, статические переменные по умолчанию инициализируются нулем.

Инициализация глобальной переменной

При желании неконстантные глобальные переменные можно инициализировать:

Константные глобальные переменные

Как и локальные переменные, глобальные переменные могут быть константными. Как и все константы, константные глобальные переменные должны быть инициализированы.

Связанный контент

Предупреждение о (неконстантных) глобальных переменных

У начинающих программистов часто возникает соблазн использовать множество глобальных переменных, потому что их можно использовать без явной передачи их каждой функции, которая в них нуждается. Однако следует вообще избегать использования неконстантных глобальных переменных! А почему, мы обсудим в следующем уроке «6.9 – Почему глобальные переменные – это зло».

Область видимости переменных в C++

В C++ существуют отдельные блоки, которые начинаются с открывающей скобки ( < ) и заканчиваются соответственно закрывающей скобкой ( >). Такими блоками являются циклы (for, while, do while) и функции.

// блок (цикл - for), также является дочерним блоком функции main // блок (цикл - for), но он еще является и дочерним блоком для первого цикла

В примере ниже, программист ошибся с областью видимости:

Он создал переменную j во втором цикле.
Использовав ее в первом цикле for он вынудил компилятор сообщить об ошибке (переменной j больше нет, поскольку второй цикл закончил свою работу).

cout << j ; // ошибка: так как переменная j была создана в другом блоке

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

Глобальные переменные в C++

Глобальными переменными называются те переменные, которые были созданы вне тела какого-то блока. Их можно всегда использовать во всей вашей программе, вплоть до ее окончания работы. В примере ниже мы создали две глобальные переменные global и global_too и использовали их в функции summa :

Вот, что выведет данная программа:

Как видите глобальные переменные видны везде. В нашем примере внутри функции summa мы не создавали ни какие переменные, мы лишь использовали две глобальные переменные, которые были созданы раньше.

Локальные переменные

Из этого можно сделать вывод: у нас есть возможность создавать переменные с одинаковыми именами, но в разных блоках (или другими словами, чтобы их область видимости не совпадала друг с другом).

int b = i ; // локальная переменная (она находится в блоке for)

Нужно запомнить! Если вы создали локальную переменную, то вы должны понимать, что использование ее в других блоках будет невозможным.

Глобальная переменная уступает локальной

Если мы создадим глобальную переменную и с таким же именем локальную, то получится, что там где была создана локальная переменная будет использоваться именно локальная переменная, а не глобальная. Так как локальная переменная считается по приоритету выше глобальной. Давайте разберем, как это работает на примере ниже:

А вот, если мы вызовем функцию sait_message то результатом будет:

Вот так глобальная переменная уступает локальной!

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

Глобальный оператор разрешения

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

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

Читайте также: