Что такое глобальная переменная
Урок №49. Глобальные переменные
Обновл. 24 Сен 2021 |
Мы уже знаем, что переменные, объявленные внутри блока, называются локальными. Они имеют локальную область видимости (используются только внутри блока, в котором объявлены) и автоматическую продолжительность жизни (создаются в точке определения и уничтожаются в конце блока).
Глобальными называются переменные, которые объявлены вне блока. Они имеют статическую продолжительность жизни, т.е. создаются при запуске программы и уничтожаются при её завершении. Глобальные переменные имеют глобальную область видимости (или «файловую область видимости»), т.е. их можно использовать в любом месте файла, после их объявления.
Определение глобальных переменных
Обычно глобальные переменные объявляют в верхней части кода, ниже директив #include, но выше любого другого кода. Например:
Подобно тому, как переменные во внутреннем блоке скрывают переменные с теми же именами во внешнем блоке, локальные переменные скрывают глобальные переменные с одинаковыми именами внутри блока, в котором они определены. Однако с помощью оператора разрешения области видимости ( :: ), компилятору можно сообщить, какую версию переменной вы хотите использовать: глобальную или локальную. Например:
Результат выполнения программы:
Global value: 3
Local value: 9
Ключевые слова static и extern
В дополнение к области видимости и продолжительности жизни, переменные имеют еще одно свойство — связь. Связь переменной определяет, относятся ли несколько упоминаний одного идентификатора к одной и той же переменной или нет.
Переменная без связей — это переменная с локальной областью видимости, которая относится только к блоку, в котором она определена. Это обычные локальные переменные. Две переменные с одинаковыми именами, но определенные в разных функциях, не имеют никакой связи — каждая из них считается независимой единицей.
Переменная, имеющая внутренние связи, называется внутренней переменной (или «статической переменной»). Она может использоваться в любом месте файла, в котором определена, но не относится к чему-либо вне этого файла.
Переменная, имеющая внешние связи, называется внешней переменной. Она может использоваться как в файле, в котором определена, так и в других файлах.
Если вы хотите сделать глобальную переменную внутренней (которую можно использовать только внутри одного файла) — используйте ключевое слово static:
6.4 – Введение в глобальные переменные
В уроке «6.3 – Локальные переменные» мы рассмотрели, что локальные переменные – это переменные, определенные внутри функции (или параметры функции). Локальные переменные имеют область видимости блока (видны только внутри блока, в котором они объявлены) и имеют автоматическую продолжительность (они создаются в точке определения и уничтожаются при выходе из блока).
В C++ переменные также могут быть объявлены вне функции. Такие переменные называются глобальными переменными.
Объявление и именование глобальных переменных
По соглашению глобальные переменные объявляются в верхней части файла, ниже включений заголовочных файлов, но выше любого кода. Ниже показан пример определения глобальной переменной:
Приведенный выше пример напечатает:
По соглашению многие разработчики добавляют к идентификаторам глобальных переменных префикс » g » или » g_ «, чтобы указать, что они глобальные.
Лучшая практика
Рассмотрите возможность использования префикса » g » или » g_ » для глобальных переменных, чтобы помочь отличить их от локальных переменных.
Глобальные переменные имеют область видимости файла и статическую продолжительность
Поскольку они определяются вне функции, глобальные переменные считаются частью глобального пространства имен (отсюда и термин «область видимости глобального пространства имен»).
Глобальные переменные создаются при запуске программы и уничтожаются при ее завершении. Это называется статической продолжительностью. Переменные со статической продолжительностью иногда называют статическими переменными.
В отличие от локальных переменных, которые по умолчанию не инициализируются, статические переменные по умолчанию инициализируются нулем.
Инициализация глобальной переменной
При желании неконстантные глобальные переменные можно инициализировать:
Константные глобальные переменные
Как и локальные переменные, глобальные переменные могут быть константными. Как и все константы, константные глобальные переменные должны быть инициализированы.
Связанный контент
Предупреждение о (неконстантных) глобальных переменных
У начинающих программистов часто возникает соблазн использовать множество глобальных переменных, потому что их можно использовать без явной передачи их каждой функции, которая в них нуждается. Однако следует вообще избегать использования неконстантных глобальных переменных! А почему, мы обсудим в следующем уроке «6.9 – Почему глобальные переменные – это зло».
Глобальные переменные C++
Концепция глобальных переменных играет очень важную роль в программировании на C ++. Это позволяет нам использовать переменную в любом месте нашей программы и изменять ее значения в соответствии с нашими требованиями. Цель написания этого руководства — познакомить вас с концепцией глобальных переменных в C ++. После этого мы также хотим поделиться с вами некоторыми примерами, с помощью которых вы сможете очень четко понять использование глобальных переменных в C ++ в Ubuntu 20.04.
Глобальные переменные в C ++ в Ubuntu 20.04
В зависимости от области действия переменные в C ++ в целом классифицируются как локальные и глобальные переменные. Область видимости переменной отличается от уровня, на котором эта переменная доступна в вашей программе. Локальная переменная — это переменная, область действия которой ограничена функцией, т. Е. Вне тела этой функции эта локальная переменная недоступна. Глобальная переменная — это переменная, область действия которой охватывает всю программу, т. Е. Ее можно получить в любом месте программы. Глобальная переменная объявляется еще до функции «main ()» в C ++ и уничтожается только после того, как ваша программа завершает свое выполнение.
Метод использования глобальных переменных в C ++ в Ubuntu 20.04
Чтобы изучить использование глобальных переменных в C ++, вам нужно будет изучить три примера, описанные ниже. Эти примеры были реализованы на C ++ в системе Ubuntu 20.04, чтобы научить вас основам работы глобальных переменных в C ++.
Пример 1
В этом примере мы намеревались выяснить влияние добавления двух чисел на глобальную переменную «сумма». Для этого мы написали программу на C ++, показанную на следующем изображении:
После включения необходимой библиотеки и пространства имен в код C ++, показанный на изображении выше, мы объявили глобальную переменную целочисленного типа с именем «sum». Мы еще не инициализировали эту переменную, что означает, что изначально эта переменная будет содержать мусорное значение. После этого у нас есть функция main (). Внутри его тела мы объявили две переменные целочисленного типа с именами «a» и «b» и присвоили им значения «10» и «20» соответственно.
Теперь мы хотим вычислить сумму этих двух переменных, сложив «a» и «b» и сохранив результат в нашей глобальной переменной «sum». Следовательно, в нашем коде есть выражение «sum = a + b». Затем мы просто напечатали значение переменной «сумма» на терминале с помощью оператора «cout». Наконец, у нас есть оператор «return 0», поскольку тип возврата нашей функции «main ()» был «int».
После того, как мы написали этот код C ++ для достижения желаемой функциональности, мы просто сохранили этот файл как «GlobalVariables.cpp». После сохранения мы выполнили в нашем терминале команду, показанную ниже, чтобы скомпилировать наш код:
После успешной компиляции нашего кода C ++ мы выполнили его, используя следующую команду:
Когда наш код C ++ был выполнен, значение нашей глобальной переменной «sum» оказалось равным «30», что фактически является суммой наших локальных переменных «a» и «b», как показано на изображении ниже. Это означает, что к глобальным переменным можно получить доступ в любом месте нашего кода, а их значениями можно легко манипулировать в соответствии с нашими потребностями. Первоначально мы не присваивали какое-либо значение нашей глобальной переменной «sum», но все же вместо отображения мусорного значения на терминале переменная «sum» содержала значение «30», так как ее мусорное значение было перезаписано в результате операция сложения в нашем коде C ++.
Пример 2
В этом примере мы хотели увидеть, как функция, отличная от функции main () в C ++, влияет на значение глобальной переменной. Для этого мы написали программу на C ++, показанную на следующем изображении:
В коде C ++, показанном на изображении выше, мы объявили глобальную переменную с именем «переменная» и инициализировали ее значением «10». Затем мы определили прототип функции с именем «square ()», которая предназначена для вычисления квадрата числа. После этого внутри нашей основной функции мы распечатали нашу глобальную переменную. Затем мы увеличили значение этой глобальной переменной, а затем распечатали это увеличенное значение. Затем мы вызвали функцию square () из функции main (). В этой функции «square ()» у нас есть оператор «переменная = переменная * переменная», который просто вычисляет квадрат нашей глобальной переменной, тем самым обновляя значение «переменной» еще раз. Затем мы распечатали значение этой обновленной переменной в теле нашей функции «square ()». Наконец-то,
Затем, после сохранения и компиляции этого кода, когда мы его выполнили, у нас было три разных значения нашей глобальной переменной, напечатанных на терминале, как показано на изображении ниже, поскольку мы дважды обновили значение этой глобальной переменной в нашем коде C ++. Сначала было напечатано первоначально присвоенное значение глобальной переменной, затем его увеличенное значение, а затем значение в квадрате.
Пример 3
В этом примере мы хотели увидеть влияние изменения значения глобальной переменной на локальную переменную, объявленную с тем же именем. Код C ++, который мы написали для этой цели, выглядит следующим образом:
В показанном выше коде C ++ мы объявили глобальную переменную целочисленного типа с именем «переменная» и присвоили ей значение «10». После этого в нашей функции «main ()» мы объявили локальную переменную целочисленного типа с тем же именем, то есть «переменная», и присвоили ей значение «20». Затем мы хотели вывести на терминал значения как локальных, так и глобальных переменных. Значение локальной переменной можно распечатать как есть; однако для ссылки на глобальную переменную с тем же именем нам придется использовать оператор «::» перед именем нашей переменной. После этого тем же оператором мы увеличили глобальную переменную. Затем мы снова распечатали значения как локальных, так и глобальных переменных, за которыми следует оператор «return 0».
После сохранения и компиляции этого кода C ++, когда мы его выполнили, начальные значения наших локальных и глобальных переменных были «20» и «10» соответственно. Однако, когда мы увеличили глобальную переменную, это не повлияло на локальную переменную с тем же именем, т. Е. Только значение глобальной переменной обновилось и стало «11», тогда как значение локальной переменной осталось неизменным, то есть «20», как вы можете видеть на изображении, показанном ниже:
Заключение
Эта статья была призвана развить правильное понимание глобальных переменных в C ++ в Ubuntu 20.04. Для этого мы сначала начали с основного определения и назначения глобальной переменной в зависимости от ее области действия. После этого мы рассмотрели три различных примера, на которых вы можете увидеть, как глобальные переменные используются в C ++. Прочитав все это руководство, вы получите достаточные знания о том, как глобальные переменные объявляются и используются в C ++ в Ubuntu 20.04.
Область видимости переменных в C++: локальные и глобальные переменные
Всем привет! Сегодня мы затронем тему, которую должны были изучить еще в самом начале пути изучения C++ — область видимости переменных. Мы разберем, что такое локальные и глобальные переменные.
Область видимости переменных в C++
Область видимости переменных — это те части программы, в которой пользователь может изменять или использовать переменные в своих нуждах.
В C++ существуют отдельные блоки, которые начинаются с открывающей скобки ( < ) и заканчиваются соответственно закрывающей скобкой ( >). Такими блоками являются циклы (for, while, do while) и функции.
Если переменная была создана в таком блоке, то ее областью видимости будет являться этот блок от его начала (от открывающей скобки — < ) и до его конца (до закрывающей скобки — >) включая все дочерние блоки созданные в этом блоке.
В примере ниже, программист ошибся с областью видимости:
А вот ошибки в строке 6 нет, поскольку второй цикл находится в первом цикле (является дочерним блоком первого цикла) и поэтому переменная b может спокойно там использоваться.
Глобальные переменные в C++
Глобальными переменными называются те переменные, которые были созданы вне тела какого-то блока. Их можно всегда использовать во всей вашей программе, вплоть до ее окончания работы. В примере ниже мы создали две глобальные переменные global и global_too и использовали их в функции summa :
Вот, что выведет данная программа:
Как видите глобальные переменные видны везде. В нашем примере внутри функции summa мы не создавали ни какие переменные, мы лишь использовали две глобальные переменные, которые были созданы раньше.
Локальные переменные
Локальные переменные — это переменные созданные в блоках. Областью видимости таких переменных является блоки ( и все их дочерние ), а также их область видимости не распространяется на другие блоки. Как ни как, но эти переменные созданы в отдельных блоках.
Из этого можно сделать вывод: у нас есть возможность создавать переменные с одинаковыми именами, но в разных блоках (или другими словами, чтобы их область видимости не совпадала друг с другом).
Нужно запомнить! Если вы создали локальную переменную, то вы должны понимать, что использование ее в других блоках будет невозможным.
Глобальная переменная уступает локальной
Если мы создадим глобальную переменную и с таким же именем локальную, то получится, что там где была создана локальная переменная будет использоваться именно локальная переменная, а не глобальная. Так как локальная переменная считается по приоритету выше глобальной. Давайте разберем, как это работает на примере ниже:
А вот, если мы вызовем функцию sait_message то результатом будет:
Вот так глобальная переменная уступает локальной!
Мы советуем вам не создавать переменные с одинаковыми именами, поскольку в будущем вам будет тяжело разобраться в коде, если там будут присутствовать одинаковые переменные.
Глобальный оператор разрешения
В случае создания двух переменных с одинаковым именем (одна из которых является глобальной, а другая локальной) при использовании в блоке, в котором была объявлена локальная переменная, можно использовать и глобальную переменную. Для ее использования нужно всего лишь применить глобальный оператор разрешения.
Глобальный оператор разрешения — это два подряд поставленные двоеточия, с помощью которых мы говорим компилятору, что хотим использовать глобальную переменную, а не локальную.
Чтобы использовать глобальный оператор разрешения нужно применять данную конструкцию:
BestProg
Содержание
Поиск на других ресурсах:
1. Что называется переменной?
Переменная (variable) в программе – это именованная ячейка памяти, которая предназначена для сохранения некоторого значения. Сохраненное значение может быть результатом вычисления выражения, числовой или строчной константой и т.д.
При разработке программы, программист по собственному усмотрению дает имена переменным. Имя переменной есть именем идентификатора. Это имя должно соответствовать синтаксису языка C/C++. Более подробно об именах переменных описывается в теме:
Для решения задачи, программист может использовать любое количество переменных в программе. Чаще всего переменные используются в выражениях при проведении вычислений.
Желательно, чтобы имя переменной отвечало ее предназначению в программе. Например, если переменная используется для сохранения некоторого максимального значения, тогда ее имя может быть Max (например).
В языке C/C++ каждая переменная должна иметь собственный тип. Более подробно о типах данных C/C++ описывается в статье:
2. Какой общий вид описания переменной в C/C++?
Общий вид описания переменной:
Переменная может иметь до 1024 символов любого имени.
Пример объявления переменных разных типов.
3. В каких местах программы можно объявлять переменные? Как классифицируются переменные в зависимости от места объявления в программе?
Переменные могут быть объявлены:
В зависимости от места объявления в программе, переменные классифицируются следующим образом:
4. Что такое локальные переменные? В каких местах программы объявляются локальные переменные?
Локальные переменные – это переменные, которые объявлены (описаны) внутри функций. Доступ к таким переменным имеют только операторы, которые используются в теле функции.
Локальные переменные создаются в момент вызова функции. Как только выполнение функции завершается, локальные переменные уничтожаются.
5. Что означает термин «разрушение переменной»?
Локальные переменные создаются в момент вызова функции. Как только выполнение функции завершается, локальные переменные разрушаются. Термин «разрушение переменной» означает: разрушение переменной в оперативной памяти после завершения функции, в которой эта переменная была объявлена.
6. Что означает термин «формальный параметр»?
Формальный параметр – это переменная, которая есть входным параметром функции. При вызове функции, ей передаются аргументы. Значение этих аргументов копируются в формальные параметры функции в порядке их вызова.
7. Что такое глобальные переменные? Какое отличие между глобальными и локальными переменными?
Глобальная переменная – это переменная, доступ к которой имеют все функции в программе. Глобальные переменные сохраняют свои значения на протяжении всего времени выполнения программы. Это время называется временем жизни глобальной переменной.
Глобальная переменная объявляется за пределами всех функций.
8. Примеры объявления переменных разных типов
9. Как выделяется память для переменных целочисленных типов?
При объявлении переменной для нее выделяется память. Размер памяти, которая выделяется, зависит от типа переменной. Размер выделенной памяти влияет на диапазон значений, которые может принимать переменная.
Для переменных целых типов выделяется память соответственно нижеследующим таблицам.
Для 16-разрядной среды.