Глобальные переменные в си: Глобальные переменные | Программирование на C и C++

Локальные и глобальные переменные.Область видимости (видео)

Для примерного понимания локализации переменных пожалуй начнем с аллегории. Что такое “Локальность”? Это ограниченность места дееспособности. Область видимости переменной – это тот участок кода (функция, цикл, пространство имени), в котором эта переменная объявлена (прописана). Вне этого участка – компилятор её не видит (она недоступна).

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

#include <iostream>

int i = 2; // глобальная переменная (видна в любом участке кода программы)

int sum()
{
int k = 2; // локальная переменная (видна только внутри функции sum())
return i + k;
}

int main()
{
std::cout << i << std::endl << sum() << std::endl;
}

если еще не встречали запись std::  — читайте тут

Во всех наших примерах, до этого момента, мы подключали пространство имён std так  using namespace std;. В этом простейшем примере,  мы обращаемся только лишь к ключевым словам  cout и endl из этого пространства, поэтому нет смысла подключать его полностью. Эффективней использовать записи std::cout и std::endl , обращаясь к пространству имён std сразу из функции main()

Во всех наших примерах, до этого момента, мы подключали пространство имён std так [crayon-60fddd216b025015050299-i/]. В этом простейшем примере,  мы обращаемся только лишь к ключевым словам  cout и endl из этого пространства, поэтому нет смысла подключать его полностью. Эффективней использовать записи std::cout и std::endl , обращаясь к пространству имён std сразу из функции main()

Давайте разберем пример поближе. Итак мы имеем переменную i, которая описана вне любых функций в программе. Ее область видимости и действия – вся программа без ограничения. А раз она “легитимна” во всей программе, во всех ее функциях и блоках операторов, заключенных в {}, то её называют Глобальной переменной.

Так же у нас в примере видна функция sum(), которая чего-то делает. В ней внутри описана вторая переменная – k. Она уже имеет конкретную “прописку” – функция. При этом данная переменная не может быть использована за пределами функции. Т.е. если в функции main()  дописать еще и вывод этой k на экран, компилятор начнет “ругаться”. Он ее просто напросто не видит вне функции sum(). Проверьте:

#include <iostream>

int i = 2; // глобальная переменная (видна в любом участке кода)

int sum()
{
int k = 2; // локальная переменная (видна только внутри функции sum())
return i + k;
}

int main()
{
std::cout << i << std::endl << sum() << std::endl;
std::cout << k << std::endl; // попытка обратиться к переменной k
}

Переменная k называется локальной, и ее область видимости определена открывающей и закрывающей фигурными скобками функции sum() – {…}. Дальше них ей хода нет, поэтому и использовать её нельзя вне этой функции. Компилируем:

Однако, нужно также учесть, что область видимости распространяется и на внутренние блоки. Для примера можно рассмотреть такой код:

#include <iostream>

int i = 2;

int sum()
{
int k = 2;

for (int i = 0; i < 10; i++) // эта i — локальная, объявленная в теле цикла
k += 1;

return i + k; // эта i — глобальная, объявленная вне функций
}

int main()
{
std::cout << i << std::endl << sum() << std::endl;
}

Здесь проявлены следующие области видимости:

• Глобальная – i = 2 принадлежит ей;
• Локальная относительно функции – переменная k;
• Локальная относительно цикла for() – вторая i.

Несмотря на то, что у for есть своя область видимости, сам for принадлежит функции sum(). А значит он, и все что в нем находится, подчиняется локальной области видимости этой функции. Т.е. все переменные, определенные в функции так же действительны и в теле for, что и позволяет работать оператору k += 1  (он же k = k+1 или k++).

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

Как только цикл свое отработал, переменная i, описанная в нём, теряет свои полномочия, или иначе говоря – “освобождается” от обязанностей. Это не шутка – именно так и поступает менеджер памяти. Когда переменная описывается, менеджер резервирует под неё память, а когда её область видимости заканчивается – память эта освобождается. Менеджер памяти у себя помечает, что этот участок памяти более не принадлежит кому-либо, и его можно отдавать под запись других данных.

Для закрепления еще один легкий примерчик:

#include <iostream>

int main()
{
int a = 0;

{
int a = 2;
std::cout << a << std::endl;
}

std::cout << a << std::endl;
}

Здесь область видимости описана блоками операторов, ограничивающимися  {}, Т.е. первый cout выведет 2, потому  что определен блок операторов, в котором сработает это cout. И в этом же блоке определена локальная переменная с именем а, из нее он и возьмет значение прежде всего.

А уже за пределами {} оператор cout выведет 0, поскольку для него не существует той а, что равнялась 2. Его область видимости совпадает с другой а, которая равна 0, и определена выше вложенного блока.

Вообще запомните – в реальной жизни никогда не надо давать одинаковые имена переменным (за исключением тех, что классически используют для счетчиков циклов. Например i, j, k. Если у вас 10 циклов в коде и они не вложенные, то для каждого из них можно объявлять и определять счетчик с именем i.  Это нормально). В других случаях, всегда давайте переменным уникальные имена, если не хотите, чтобы вас потом “вспоминали” программисты, которые будут разбираться в вашем коде.

Предлагаем также просмотреть видео-урок по теме область видимости.

C++ — Область переменных

Область переменной является областью программы, где переменные могут быть объявлены:

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

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

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

#include <iostream>
using namespace std;
 
int main () {
   // Local variable declaration:
   int a, b;
   int c;
 
   // actual initialization
   a = 10;
   b = 20;
   c = a + b;
 
   cout << c;
 
   return 0;
}

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

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

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

#include <iostream>
using namespace std;
 
// Global variable declaration:
int g;
 
int main () {
   // Local variable declaration:
   int a, b;
 
   // actual initialization
   a = 10;
   b = 20;
   g = a + b;
  
   cout << g;
 
   return 0;
}

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

#include <iostream>
using namespace std;
 
// Global variable declaration:
int g = 20;
 
int main () {
   // Local variable declaration:
   int g = 10;
 
   cout << g;
 
   return 0;
}

Когда приведенный выше код компилируется и выполняется, он производит следующий результат:

10

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

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

Хорошая практика программирования — правильно инициализировать переменные, иначе программа может вызвать неожиданный результат.

Глобальная переменная си шарп

Переменные могут быть полями класса, объявляться в функциях или даже внутри циклов (например: for (int i=0; i

Область видимости, или контекст переменной — это часть кода, в пределах которого доступна данная переменная. В общем случае такая область определяется описанными ниже правилами:
1. Поле, также известное как переменная-член класса, находится в области видимости до тех пор, пока в этой области находится содержащий поле класс.
2. Локальная переменная находится в области видимости до тех пор, пока закрывающая фигурная скобка не укажет конец блока операторов или метода, в котором она объявлена.
3. Локальная переменная, объявленная в операторах цикла for, while или подобных им, видима в пределах тела цикла.

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

Однако следует иметь в виду, что локальные переменные с одним и тем же именем не могут быть объявлены дважды в одном и том же контексте, поэтому вы не сможете поступить так, как показано ниже:
int х = 20;
// какой-то код
int х = 30;

Рассмотрим следующий пример кода с локальной переменной k (оператор цикла for изучается дальше):

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

Если вы попытаетесь скомпилировать это, то получите следующее сообщение об ошибке:
Ошибка: Невозможно объявить локальную переменную с именем «k» в этой области видимости, т.к. она придаст другое значение «k», которая уже используется в области видимости «родительский или текущий» для обозначения чего-то другого.
Дело в том, что переменная k, которая определена перед началом цикла for, внутри цикла все еще находится в области видимости и не может из нее выйти до завершения метода Main().
Хотя вторая переменная k (недопустимая) объявлена в контексте цикла, этот контекст вложен в контекст метода Main(). Компилятор не может различить эти две переменных, поэтому не допустит объявления второй из них.

Конфликты областей видимости полей и локальных переменных. В некоторых случаях два идентификатора с одинаковыми именами (хотя и не совпадающими полностью уточненными именами) и одинаковой областью видимости можно различить, и тогда компилятор допускает объявление второй переменной. Причина в том, что C# делает принципиальное различие между переменными, объявленными на уровне типа (в примере — полями класса) и переменными, объявленными в методах (локальными переменными).

Рассмотрим третий пример:

Этот код компилируется, несмотря на то, что здесь в контексте метода Main() присутствуют две переменных с именем k: переменная k, определенная на уровне класса и существующая до тех пор, пока не будет уничтожен класс (когда завершится метод Main(), а вместе с ним и программа), и переменная k, определенная внутри Main().

В данном случае новая переменная с именем k, объявленная в методе Main(), игнорирует переменную уровня класса с тем же именем. Поэтому когда вы запустите этот код, на дисплее будет отображено число 30.
В языке C# локальные переменные широко используются именно из-за аппарата разграничения области видимости. Не экономьте без необходимости на локальных переменных, если они не занимают большой объем памяти.

Следующее интуитивно понятие языка программирования — Литералы.

Необходимо воспользоваться в классе C полями класса A. Как это возможно сделать? Вне классов создавать переменные нельзя, дальше уже namespace

1 ответ 1

Автор, если тебе действительно нужны «глобальные переменные», то в .NET это static-поля и свойства.

Но если тебе нужно просто разделить общий ресурс между несколькими компонентами, то ты либо передаёшь один в конструктор или метод другого, делая поля/свойства публичными, либо выносишь их в отдельный класс-контекст, который спускаешь в конструктор/метод каждого класса, который их использует. Основы ООП.

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

8 ответов

да, вы можете использовать статический класс. вот так:

и через любой, где вы можете написать:

или вы можете поместить свои глобалы в app.config

Обозреватель > Проект > Свойства > Параметры.Настройки. Нажмите на этот файл и добавьте определение параметров из среды IDE.

консенсус здесь заключается в том, чтобы поместить глобальные переменные в статический класс как статические члены. Когда вы создаете новое приложение Windows Forms, оно обычно поставляется с классом программы (Program.cs), который является статическим классом и служит основной точкой входа приложения. Он живет на всю жизнь приложения, поэтому я думаю, что лучше поместить глобальные переменные там, а не создавать новый.

и используйте его как таковой:

Если вы используете Visual C# все, что вам нужно сделать, это добавить класс в программу.cs наследует форму и изменяет весь унаследованный класс из формы в ваш класс в каждой форме*.цезий.

конечно, может быть способ расширение формы класса без ее изменения. Если это так, все, что вам нужно сделать, это продлить его! Поскольку все формы наследуют его по умолчанию, все объявленные в нем ценности автоматически станут глобальными! Хороший удачи.

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

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

явный перевод текста на испанском языке:

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

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

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

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

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

еще одна проблема-порядок уничтожения. Переменные всегда уничтожаются в обратном порядке их создания, будь то локальные или глобальные / статические переменные (исключение составляют примитивные типы, int , enum s и т. д., который никогда не уничтожаются, если они являются глобальными / статическими, пока они не закончат программу).

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

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

но если у вас больше одного .cpp каждый со своими глобальными / статическими переменными, глобальный порядок построения является неопределенным. Конечно, порядок в каждой единице компиляции (каждый .cpp ) в частности, соблюдается: если глобальная переменная A определен до B , A будет построен до B , но возможно, что между A и B переменные другие .cpp инициализируются. Например, если у вас есть три единицы с следующие глобальные / статические переменные:

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

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

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

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

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

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

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

если слишком много глобальных объектов и слишком много параметров в функциях, которым они нужны, вы всегда можете сгруппировать свои «глобальные объекты» в класс style * factory *, который строит и возвращает экземпляр «глобального объекта» (смоделированный), который вы хотите, передавая фабрику в качестве параметра к объектам, которые нуждаются в глобальном объекте как зависимости.

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

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

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

другой может быть неинтрузивными «глобальными» службами, такими как класс ведения журнала (сохранение того, что происходит в файле, который обычно необязательный и настраиваемый в программе, и поэтому не влияет на ядерное поведение приложения), или std :: cout , std :: cin или std :: cerr , которые также являются глобальными объектами.

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

Локальные и глобальные переменные. Курс «Python. Введение в программирование»

В программировании особое внимание уделяется концепции о локальных и глобальных переменных, а также связанное с ними представление об областях видимости. Соответственно, локальные переменные видны только в локальной области видимости, которой может выступать отдельно взятая функция. Глобальные переменные видны во всей программе. «Видны» – значит, известны, доступны. К ним можно обратиться по имени и получить связанное с ними значение.

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

Вернемся к нашей программе из прошлого урока, немного упростив ее для удобства:

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    print("Площадь: %.2f" % (a*b))
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    print("Площадь: %.2f" % (0.5 * a * h))
 
figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()

Сколько здесь переменных? Какие из них являются глобальными, а какие – локальными?

Здесь пять переменных. Глобальной является только figure. Переменные a и b из функции rectangle, а также a и h из triangle – локальные. При этом локальные переменные с одним и тем же идентификатором a, но объявленные в разных функциях, – разные переменные.

Следует отметить, что идентификаторы rectangle и triangle, хотя и не являются именами переменных, а представляют собой имена функций, также имеют область видимости. В данном случае она глобальная, так как функции объявлены непосредственно в основной ветке программы.

В приведенной программе к глобальной области видимости относятся заголовки объявлений функций, объявление и присваивание переменной figure, конструкция условного оператора.

К локальной области относятся тела функций. Если, находясь в глобальной области видимости, мы попытаемся обратиться к локальной переменной, то возникнет ошибка:

…
elif figure == '2':
    triangle()
 
print(a)

Пример выполнения:

1-прямоугольник, 2-треугольник: 2
Основание: 4
Высота: 5
Площадь: 10.00
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print(a)
NameError: name 'a' is not defined

Однако мы можем обращаться из функций к глобальным переменным:

def rectangle():
    a = float(input("Ширина %s: " % figure))
    b = float(input("Высота %s: " % figure))
    print("Площадь: %.2f" % (a*b))
 
def triangle():
    a = float(input("Основание %s: " % figure))
    h = float(input("Высота %s: " % figure))
    print("Площадь: %.2f" % (0.5 * a * h))
 
figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()

Пример выполнения:

1-прямоугольник, 2-треугольник: 1
Ширина 1: 6.35
Высота 1: 2.75
Площадь: 17.46

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

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

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

result = 0
 
def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    result = a*b
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    result = 0.5 * a * h
 
figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()
 
print("Площадь: %.2f" % result)

Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать. Однако…

1-прямоугольник, 2-треугольник: 2
Основание: 6
Высота: 4.5
Площадь: 0.00

… что-то пошло не так.

Дело в том, что в Python присвоение значения переменной совмещено с ее объявлением. (Во многих других языках это не так.) Поэтому, когда имя result впервые упоминается в локальной области видимости, и при этом происходит присваивание ей значения, то создается локальная переменная result. Это другая переменная, никак не связанная с глобальной result.

Когда функция завершает свою работу, то значение локальной result теряется, а глобальная не была изменена.

Когда мы вызывали внутри функции переменную figure, то ничего ей не присваивали. Наоборот, мы запрашивали ее значение. Интерпретатор Питона искал ее значение сначала в локальной области видимости и не находил. После этого шел в глобальную и находил.

В случае с result он ничего не ищет. Он выполняет вычисления справа от знака присваивания, создает локальную переменную result, связывает ее с полученным значением.

На самом деле можно принудительно обратиться к глобальной переменной. Для этого существует команда global:

result = 0
 
def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    global result
    result = a*b
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    global result
    result = 0.5 * a * h
 
figure = input("1-прямоугольник, 2-треугольник: ")
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()
 
print("Площадь: %.2f" % result)

В таком варианте программа будет работать правильно.

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

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

Как функция принимает и возвращает данные, будет рассмотрено в следующих уроках.

Практическая работа

В языке Python можно внутри одной функции определять другую. Напишите программу по следующему описанию.

В основной ветке программы вызывается функция cylinder(), которая вычисляет площадь цилиндра. В теле cylinder определена функция circle, вычисляющая площадь круга по формуле πr². В теле cylinder у пользователя спрашивается, хочет ли он получить только площадь боковой поверхности цилиндра, которая вычисляется по формуле 2πrh, или полную площадь цилиндра. В последнем случае к площади боковой поверхности цилиндра должен добавляться удвоенный результат вычислений функции circle().

Как вы думаете, можно ли из основной ветки программы вызвать функцию, вложенную в другую функцию? Почему?

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

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

На чтение 12 мин Просмотров 77 Опубликовано 31.03.2021

Сущность в C ++ имеет имя, которое может быть объявлено и / или определено. Объявление — это определение, но определение не обязательно является декларацией. Определение выделяет память для названного объекта, но объявление может или не может выделять память для названного объекта. Декларативная область — это самая большая часть программы, в которой допустимо имя объекта (переменной). Эта область называется областью действия или потенциальной областью действия. В этой статье объясняется область видимости в C ++. Кроме того, для понимания этой статьи необходимы базовые знания C ++.

Декларативный регион и объём

Декларативная область — это самая большая часть текста программы, в которой допустимо имя объекта. Это регион, в котором неквалифицированное имя может использоваться (отображаться) для обозначения одного и того же объекта. Рассмотрим следующую короткую программу:

#include <iostream>
using namespace std;

void fn()
{
int var = 3;
if (1==1)
{
cout<<var<<‘\n‘;
}
}

int main()
{
fn();
return ;
}

Функция fn () имеет два блока: внутренний блок для условия if и внешний блок для тела функции. Идентификатор var вводится и отображается во внешнем блоке. Это также видно во внутреннем блоке с оператором cout. Внешний и внутренний блоки являются областью для имени var.

Однако имя var по-прежнему можно использовать для объявления другой сущности, такой как float, во внутреннем блоке. Следующий код иллюстрирует это:

#include <iostream>
using namespace std;

void fn()
{
int var = 3;
if (1==1)
{
float var = 7.5;
cout<<var<<‘\n‘;
}
}

int main()
{
fn();
return ;
}

Выход 7.5. В этом случае имя var больше не может использоваться во внутреннем блоке для ссылки на целое число значения 3, которое было введено (объявлено) во внешнем блоке. Такие внутренние блоки называются потенциальной областью для сущностей, объявленных во внешнем блоке.

Примечание. Сущность того же типа, что и внешний блок, все еще может быть объявлена ​​во внутреннем блоке. Однако в этом случае во внутреннем блоке допустимо новое объявление и его значение, в то время как старое объявление и его значение вне внутреннего блока остаются действительными во внешнем блоке.

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

Глобальная область

Когда программист только начинает печатать файл, это глобальная область видимости. Следующая короткая программа иллюстрирует это:

#include <iostream>
using namespace std;

float var = 9.4;

int main()
{
cout <<var<<‘\n‘;
cout <<::var<<‘\n‘;

return ;
}

Результат:
9,4
9,4

В этом случае декларативная область или область видимости для var начинается с точки объявления для var, продолжается вниз до конца файла (единицы трансляции).

Блок функции main () имеет другую область видимости; это вложенная область видимости для глобальной области видимости. Для доступа к объекту глобальной области из другой области идентификатор используется непосредственно или перед ним стоит оператор разрешения области, ::.

Примечание. Сущность main () также объявлена ​​в глобальной области видимости.

Область действия блока

Каждый оператор if, while, do, for или switch может определять блок. Такое утверждение является составным утверждением. Имя переменной, объявленной в блоке, имеет область видимости блока. Его область действия начинается в точке объявления и заканчивается в конце блока. Следующая короткая программа иллюстрирует это для переменной идент:

#include <iostream>
using namespace std;

int main()
{
if (1==1)
{
/*some statements*/
int ident = 5;
cout<<ident<<‘\n‘;
/*some statements*/
}
return ;
}

Переменная, такая как идентификатор, объявленная в области блока, является локальной переменной.

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

#include <iostream>  
using namespace std;

int main()
{
int identif = 8;

if (identif == 8)
{
cout<<identif<<‘\n‘;
}
return ;
}

Результатом будет 8. Здесь есть две области видимости блока: блок для функции main () и вложенный оператор if-complex. Вложенный блок является потенциальной областью функционального блока main ().

Объявление, введенное в области видимости блока, не может быть видно за пределами блока. Следующая короткая программа, которая не компилируется, иллюстрирует это с помощью переменной variab:

#include <iostream>  
using namespace std;

int main()
{
if (1 == 1)
{
int variab = 15;
}
cout<<variab<<‘\n‘;    //error: accessed outside its scope.

return ;
}

Компилятор выдает сообщение об ошибке для переменной.

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

#include <iostream>
using namespace std;int main()
{
for (int i=; i<4; ++i)
{
cout<<i<<‘ ‘;
}
cout<<i<<‘ ‘;

return ;
}

Переменная итерации i видна внутри блока цикла for, но не вне блока цикла for.

Область функции

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

#include <iostream>
#include <string>
using namespace std;

string fn(string str)
{
char stri[] = «bananas»;
/*other statements*/
string totalStr = str + stri;
return totalStr;
}

int main()
{
string totStr = fn(«eating «);
cout<<totStr<<‘\n‘;

return ;
}

Результат:
есть бананы

Примечание. Сущность, объявленная вне функции (над ней), можно увидеть в списке параметров функции, а также в функциональном блоке.

Объем метки

Объем метки — это функция, в которой она появляется. Следующий код иллюстрирует это:

#include <iostream>
using namespace std;

void fn()
{
goto labl;
/*other statements*/
labl: int inte = 2;
cout<<inte<<‘\n‘;
}

int main()
{
fn();

return ;
}

Выход 2.

Область перечисления

Перечисление без области действия
Рассмотрим следующий блок if:

if (1==1)
{
enum {a, b, c=b+2};
cout<<a<<‘ ‘<<b<<‘ ‘<<c<<‘\n‘;
}

На выходе будет 0 1 3.

Первая строка в блоке — это перечисление, a, b и c — его перечислители. Область действия перечислителя начинается с точки объявления до конца включающего блока перечисления.

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

enum {a=c+2, b, c};

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

if (1==1)
{
enum {a, b, c=b+2};
}
cout<<a<<‘ ‘<<b<<‘ ‘<<c<<‘\n‘;  //error: out of scope

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

Перечисление с областью действия

Следующее утверждение подходит:

enum class nam {a, b, c=b+2};

Это пример перечисления с ограниченной областью видимости. Имя класса — nam. Здесь область действия перечислителя начинается с точки объявления до конца определения перечисления, а не от конца включающего блока для перечисления. Следующий код не компилируется:

if (1==1)
{
enum class nam {a, b, c=b+2};
cout<<a<<‘ ‘<<b<<‘ ‘<<c<<‘\n‘;   //error: out of scope for enum class or enum struct  
}

Область действия класса

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

#include <iostream>
using namespace std;

//Base class
class Cla
{
private:
int memP = 5;
protected:
int memPro = 9;
public:
void fn()
{
cout<<memP<<‘\n‘;
}
};

//Derived Class
class DerCla: public Cla
{
public:
int derMem = memPro;
};
int main()
{
Cla obj;
obj.fn();
DerCla derObj;
cout<<derObj.derMem<<‘\n‘;

return ;
}

Результат:
5
9

В классе Cla переменная memP видна в точке объявления. После этого короткая часть «protected» пропускается, а затем снова отображается в функциональном блоке-члене класса. Производный класс пропускается, а затем снова отображается в области (блоке) функции main ().

В классе Cla переменная memPro видна в точке объявления. Часть общедоступной функции fn () пропускается, а затем отображается в блоке описания производного класса. Это снова видно в функции main ().

Оператор разрешения области действия

Оператором разрешения области действия в C ++ является ::. Он используется для доступа к статическому члену класса. Следующая программа иллюстрирует это:

#include <iostream>
using namespace std;

class Cla
{
public:
static int const mem = 5;
public:
static void fn()
{
cout<<mem<<‘\n‘;
}
};
int main()
{
cout<<Cla::mem<<‘\n‘;
Cla::fn();

return ;
}

Результат:
5
5

Статические члены видны в функциональном блоке main (), доступ к которому осуществляется с помощью оператора разрешения области видимости.

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

Обычная область действия имени параметра шаблона начинается с момента объявления до конца его блока, как в следующем коде:

template<typename T, typename U>  struct Ages
{
T John = 11;
U Peter  = 12.3;
T Mary  = 13;
U Joy   = 14.6;
};

U и T видны внутри блока.

Для прототипа шаблонной функции область действия начинается от точки объявления до конца списка параметров функции, как в следующем заявлении:

template<typename T, typename U> void func (T no, U cha, const char *str );

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

#include <iostream>
using namespace std;

template<class T, class U> class TheCla
{
public:
T num;
static U ch;

void func (U cha, const char *str)
{
cout << «There are « << num << » books worth « << cha << str << » in the store.» << ‘\n‘;
}
static void fun (U ch)
{
if (ch == ‘a’)
cout << «Official static member function» << ‘\n‘;
}
};

int main()
{
TheCla<int, char> obj;
obj.num = 12;
obj.func(‘$’, «500»);

return ;
}

Скрытие имени

Пример сокрытия имени происходит, когда имя того же типа объекта повторно объявляется во вложенном блоке. Следующая программа иллюстрирует это:

#include <iostream>
using namespace std;

void fn()
{
int var = 3;
if (1==1)
{
int var = 4;
cout<<var<<‘\n‘;
}
cout<<var<<‘\n‘;
}

int main()
{
fn();
return ;
}

Результат:
4
3

Это потому, что var во вложенном блоке спрятал var во внешнем блоке.

Возможность повторения декларации в том же объеме

Смысл объявления в том, что имя вводится (впервые) в его область видимости.

Прототип функции

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

#include <iostream>
using namespace std;

void fn(int num);
void fn(int num);

void fn(int num)
{
cout<<num<<‘\n‘;
}

int main()
{
fn(5);

return ;
}

Программа работает.

Перегруженные функции

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

#include <iostream>
using namespace std;

void fn(int num)
{
cout<<num<<‘\n‘;
}

void fn(float no)
{
cout<<no<<‘\n‘;
}

int main()
{
fn(5);
float flt = 8.7;
fn(flt);

return ;
}

Результат:
5
8,7

Перегруженные функции определены в глобальной области.

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

Область действия пространства имен заслуживает отдельной статьи. Указанная статья написана для этого веб-сайта linuxhint.com. Просто введите поисковые слова «Namespace Scope» в поле поиска на этом сайте (странице) и нажмите «ОК», и вы получите статью.

Объем в разных частях

Класс — не единственная схема, в которой область видимости может быть в разных частях. Спецификатор друга, определенные варианты использования спецификатора детализированного типа и директивы using — это другие схемы, в которых область видимости находится в разных местах — подробности см. Ниже.

Заключение

Область видимости — это декларативная область. Декларативная область — это самая большая часть текста программы, в которой допустимо имя объекта. Его можно разделить на несколько частей в соответствии с определенными схемами программирования, такими как вложенные блоки. Части, не имеющие точки объявления, образуют потенциальную область видимости. Потенциальная область может иметь или не иметь декларацию.

Переменная сфера C ++

Область является региональной программой, в общем, есть три места, которые вы можете объявлять переменные:

• Функция или переменная объявлена ​​внутри блока кода, называются локальными переменными.
• Переменные, объявленные в определении параметров функции, называются формальными параметрами.
• Все переменные, объявленные вне функции, называются глобальными переменными.

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

Функция или переменная объявлена ​​внутри блока кода, называются локальными переменными. Они могут быть использованы только внутри функции или блока кода внутри оператора. В следующем примере используются локальные переменные:

#include <iostream>
using namespace std;
 
int main ()
{
  // 局部变量声明
  int a, b;
  int c;
 
  // 实际初始化
  a = 10;
  b = 20;
  c = a + b;
 
  cout << c;
 
  return 0;
}

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

Глобальные переменные могут быть доступны любой функции. Другими словами, глобальная переменная объявлена ​​как только в течение всей программы доступны. В следующем примере используются глобальные и локальные переменные:

#include <iostream>
using namespace std;
 
// 全局变量声明
int g;
 
int main ()
{
  // 局部变量声明
  int a, b;
 
  // 实际初始化
  a = 10;
  b = 20;
  g = a + b;
 
  cout << g;
 
  return 0;
}

В программе, локальные переменные и глобальные переменные могут быть одинаковыми, но внутри функции, локальные переменные перекроет значение глобальной переменной. Вот пример:

#include <iostream>
using namespace std;
 
// 全局变量声明
int g = 20;
 
int main ()
{
  // 局部变量声明
  int g = 10;
 
  cout << g;
 
  return 0;
}

Когда приведенный выше код компилируется и выполняется, он дает следующие результаты:

10

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

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

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

Напомним, что каждый модуль (процедура, функция, программа) состоит из заголовка (procedure…, function…, program…) и блока.

Если блок какой-либо процедуры p1 содержит внутри процедуру p2, то говорят, что p2 вложена в p1.

Пример.

procedure p1(x: real; var y: real);
    var c: integer;
    procedure p2(var z: real);
        …………………….
    end;
    begin
        …………………….
    end;

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

Пример.

procedure t1;
    var y1, y2: real;
    procedure sq1;
        var a, b, c, d: real;
        begin
            { Переменные a, b, c, d являются локальными для sq1,
               область их действия – процедура sq1 }
            ……………………………………
        end;
    begin
        { Переменные y1, y2 - нелокальные для sq1,
           область их действия – t1 и sq1 }
    end;

Константы, переменные, типы, описанные в блоке program, называются глобальными. Казалось бы, проще иметь дело вообще только с глобальными переменными, описав их все в program. Но использование локальных переменных позволяет системе лучше оптимизировать программы, делать их более наглядными и уменьшает вероятность появления ошибок.

При написании программ, имеющих вложенные модули, необходимо придерживаться следующих правил:

1. Описывать идентификаторы в том блоке, где они используются, если это возможно.
2. Если один и тот же объект (переменная, тип, константа) используются в двух и более блоках, то описать этот объект надо в самом внешнем из них, содержащем все остальные блоки, использующие данный объект.
3. Если переменная, используемая в процедуре, должна сохранить свое значение до следующего вызова этой процедуры, то такую переменную надо описать во внешнем блоке, содержащем данную процедуру.

Локализация переменных дает программисту большую свободу в выборе идентификаторов. Так, если две процедуры a и b полностью отделены друг от друга (т.е. не вложены одна в другую), то идентификаторы в них могут быть выбраны совершенно произвольно, в частности, могут повторяться. В этом случае совпадающим идентификаторам соответствуют разные области памяти, совершенно друг с другом не связанные.

Пример.

var k: integer;
procedure a;
    var x, z: real;
    begin
        { через x, z обозначены две величины –
        локальные переменные для a;
        k – глобальная переменная для a }
        …………………………………
    end;
procedure b;
    var x, y: integer;
    begin
        { через x, y обозначены две другие величины –
        локальные переменные для b;
        k – глобальная переменная для b }
        …………………………………
    end;
begin
{ k – единственная переменная, которую 
можно использовать в основной ветке программы }
…………………………………
end.

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

var
    i: integer;
    a: real;
 
procedure p(var d: real);
    var i: integer;
    begin
        i := 3;
        d := i + 10 * d;
    end;
 
begin
    a := 2.0;
    i := 15;
    p(a);
    writeln(' i = ', i, ' a = ', a);
 
readln
end.

Глобальным переменным i и a отводятся две ячейки памяти. Первыми выполняются операторы a := 2.0 и i := 15. Затем вызывается процедура p(a). В процессе работы p отводится ячейка для локальной переменной i и туда засылается число 3. После окончания работы процедуры p эта ячейка i программой «забывается». После возврата на оператор writeln программа знает только одну ячейку i – глобальную, т.е. ту, которая содержит число 15. Поэтому программа выдаст на печать i = 15, a = 23.0, т.к. a = 3 + 10 * 2.

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

Пример.

type ab = array[1..3] of real;
var a: ab;
procedure q;
    var b: ab;
    …………………………..
end;

В этом примере переменные a и b описаны через общий тип ab. Если же локальная и глобальная переменные описаны одинаково, но не через общий тип, то программа может «не понять», что эти переменные принадлежат одному типу.

Пример.

var a: array[1..3] of real;
procedure q;
    var b: array[1..3] of real;
    ……………………….
end;

В этом примере переменные a и b – одинаковые массивы, т.е. типы этих переменных одинаковы, но программа, тем не менее, «не считает», что a и b принадлежат одному типу. Это происходит из-за того, что описание массивов дано в разных блоках.

глобальных переменных, extern, static, const

глобальных переменных, extern, static, const

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

Локальная переменная — это переменная, которая встречается в определенной области. Они существуют
только в той функции, в которой они созданы.

Иногда их называют автоматическими переменными , потому что они
автоматически создается, когда функция начинает выполнение, и автоматически
прочь, когда функция завершит выполнение.

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

Глобальные переменные и внешние

Глобальная переменная — это переменная, которая определяется вне всех функций
и доступен для всех функций.

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

Можно создать глобальную переменную в одном файле и получить к ней доступ из
другой файл.Для этого переменная должна быть объявлена ​​в обоих файлах,
но ключевое слово extern должно предшествовать «второму» объявлению.

Статические переменные

Статическая переменная может быть глобальной или локальной переменной. Оба
создается путем предшествования объявлению переменной ключевого слова static .

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

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

Глобальная статическая переменная — это переменная, к которой можно получить доступ только в файле
где он создан. Считается, что эта переменная имеет область видимости файла .

Постоянные переменные

В C директива препроцессора #define использовалась для создания переменной с
постоянное значение. Это все еще работает в C ++, но могут возникнуть проблемы.

Когда используется #define, препроцессор просматривает код и заменяет
каждый экземпляр переменной #defined с соответствующим значением. Ну, так как
переменная #defined существует только в том файле, в котором она создана, это возможно
иметь такое же определение в другом файле с совершенно другим значением. Этот
может привести к плачевным последствиям.

Чтобы преодолеть эту проблему, концепция именованной константы, которая похожа на
переменная была введена в C ++.

Чтобы создать постоянную переменную в C ++, перед объявлением переменной укажите
ключевое слово const . Это сообщает компилятору, что «переменная была
создано, значение которого не может быть изменено «

При создании постоянной переменной ей ДОЛЖНО быть присвоено значение.

6.4 — Введение в глобальные переменные

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

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

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

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

В приведенном выше примере печатается:

 3
3
5
 

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

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

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

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

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

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

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

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

Непостоянные глобальные переменные могут быть дополнительно инициализированы:

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

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

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

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

Краткое описание

Есть ли глобальные переменные в C, статические или внешние?

Вы смешиваете static и длительность статического хранения .

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

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

Переменная, объявленная в области файла, но без какого-либо спецификатора класса хранения (ни static , ни extern ) не имеет внешней связи , но она по-прежнему имеет статическую продолжительность хранения. С 6.2.4:

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

Но если вы добавляете спецификатор класса хранения к переменной области файла, вы указываете как продолжительность хранения, так и связь .6.2.4 / 3:

Если объявление идентификатора области файла для объекта или функции содержит спецификатор класса хранения static , идентификатор имеет внутреннюю связь.

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

Здесь есть небольшая разница в том случае, если вы добавляете static к локальной переменной — тогда она указывает продолжительность хранения, но не привязку.Весь термин «связь» довольно сбивает с толку — проще говоря, цель термина — указать, когда две переменные с одинаковым именем относятся к одному и тому же объекту или к разным. Это больше всего беспокоит тех, кто создает компиляторы / компоновщики, а также программистов-спагетти. Избегайте принадлежности к последней категории, следуя советам ниже.

Новичкам не нужно беспокоиться ни о чем из вышеперечисленного.
Эмпирические правила для начинающих:

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

Это уведет вас очень далеко, и редкие случаи, когда вам действительно нужно разделить переменные между разными файлами, — это отдельная история / сложная тема.

Адское программирование и глобальные переменные

«Дорога в ад программирования вымощена глобальными переменными» — Стив МакКоннелл, Code Complete

«Глобалы несут ответственность за все зло во Вселенной, от облысения по мужскому типу до истощения озонового слоя.- Джек Гэнссл, Марс съел мой космический корабль!

Глобальные переменные обычно не приветствуются в программировании. Наличие нескольких функций, потенциально изменяющих состояние одной переменной, может привести к серьезным проблемам. Согласно Филу Купману из Better Embedded Systems Software, глобальные переменные — зло. Глобальная переменная — это переменная с глобальной областью действия, поэтому она напрямую видна всей программной системе. Рекомендации по программному обеспечению MISRA не рекомендуют использовать глобальные переменные (Отчет MISRA 5, стр.10). IEC 61508-3 рекомендует модульный подход (стр. 79), скрытие / инкапсуляцию информации (id., Стр. 93) и полностью определенный интерфейс (id., Стр. 93), который в основном рекомендует не использовать глобальные переменные.

Проблемы с глобальными переменными

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

Глобальные переменные также могут добавлять к межкомпонентной связи. Это увеличивает сложность, если их использует большое количество компонентов. Дополнительная взаимосвязь и сложность упрощают разработчикам возможность непреднамеренного добавления дефектов в программное обеспечение при выполнении обновлений.Найти и исправить эти дефекты сложнее. Связь с глобальными переменными увеличивает затраты (время и усилия), необходимые для внесения изменений в код. Все это влияет на влияние изменений. НАСА рекомендует избегать «слишком большого количества межкомпонентных зависимостей. Чтобы обеспечить максимальное повторное использование программного обеспечения, компоненты не должны комплексно зависеть друг от друга », что включает использование глобальных переменных для передачи данных между компонентами. (NASA 2004, стр. 93)

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

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

• Когда исходный код для глобальной переменной изменяется, все, что его использует, должно быть перекомпилировано, потому что все должно знать его новое размер и объем памяти.
• Если несколько компонентов могут писать в глобальную переменную, это может привести к несогласованности данных в ней. Если приложение является многопоточным, необходимо использовать механизм блокировки, чтобы только один поток мог изменять переменную за раз.Если несколько компонентов общаются друг с другом через глобальные переменные, понять, какой компонент изменяет глобальную переменную, а также когда и как это происходит, может быть очень сложно.
• Глобальные переменные также могут привести к конфликту имен, когда одно и то же имя переменной используется как локальной переменной, так и глобальной переменной. Это скрывает глобальный. Для правильной работы программного обеспечения необходимо устранить конфликт. Существует несколько способов исправить или избежать конфликтов имен, в том числе:
  • Пространства имен — квалификация каждого имени другим именем группы, чтобы полные имена отличались друг от друга
  • Переименование — изменение имени либо глобальной переменной, либо локальной переменная
  • Префикс — размещение уникального символа (ов) перед каждым именем, чтобы имена различались

Резюме

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

Если у вас возникли проблемы с отслеживанием глобальных переменных, у Lattix Architect есть отчет о глобальных переменных, который отслеживает все их чтение и запись.Щелкните здесь, чтобы получить дополнительную информацию и запланировать оценку.

Как мы можем получить доступ к глобальным переменным в C

Как мы можем получить доступ к глобальным переменным в C:

Глобальные переменные — это переменные в C , которые доступны из любого метода. Локальные переменные доступны только в той функции, в которой они определены. Например, давайте рассмотрим приведенный ниже пример программы:

  #include 

void anotherFunction ()
{
    int result = 30;
    printf ("результат в anotherFunction =% d \ n", результат);
}
int main ()
{
    int result = 20;
    printf ("результат в main =% d \ n", результат);
    anotherFunction ();
}  

Здесь у нас есть основная функция и еще одна функция с именем anotherFunction .Мы вызываем на другую функцию с основного номера . Обратите внимание, что у нас есть две переменные с одинаковым именем результат определены в этих функциях.

Если вы запустите эту программу, она сначала напечатает значение result в main , а затем напечатает результат в anotherFunction . Обе эти переменные result являются локальными переменными. Таким образом, их области действия ограничены внутри их собственной функции, в которой они определены.

Но область видимости глобальной переменной не ограничивается функцией. Глобальные переменные определены вне всех функций, и к ним можно получить доступ из всех других функций. Но как мы можем получить доступ к глобальной переменной из функции? Например, если мы создадим одну переменную result как глобальную переменную, как мы можем получить к ней доступ из main или anotherFunction ?

Это действительно просто. Для этого нам нужно использовать одно ключевое слово под названием extern .Позвольте мне показать вам, как это сделать.

Ключевое слово extern для доступа к глобальным переменным в C:

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

Давайте посмотрим на приведенный ниже пример программы:

  #include 
int result = 100;

int main ()
{
    int result = 20;

    {
        extern int результат;
        printf ("Глобальный результат =% d \ n", результат);
    }
    
    printf ("результат в main =% d \ n", результат);
}  

Будет напечатан следующий результат:

  Глобальный результат = 100
result in main = 20  

Итак, вы можете видеть, что мы печатаем значение обеих переменных result .Один локальный, а другой глобальный.

Кроме того, вам не нужен дополнительный блок, если имя вашей глобальной переменной отличается от local:

  #include 
int globalVar = 100;

int main ()
{
    int result = 20;
    extern int globalVar;
    printf ("Глобальный результат =% d \ n", globalVar);

    printf ("результат в main =% d \ n", результат);
}  

Вам также могут понравиться:

Python Глобальные, локальные и нелокальные переменные (с примерами)

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

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

Давайте посмотрим на примере создания глобальной переменной в Python.

Пример 1. Создание глобальной переменной

  x = "глобальный"

def foo ():
    print ("x внутри:", x)


foo ()
print ("x снаружи:", x)  

Выход

  x внутри: глобально
x снаружи: глобальный  

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

Что делать, если вы хотите изменить значение x внутри функции?

  x = "глобальный"

def foo ():
    х = х * 2
    печать (х)

foo ()  

Выход

  UnboundLocalError: локальная переменная 'x', на которую имеется ссылка перед присваиванием  

Вывод показывает ошибку, потому что Python обрабатывает x как локальную переменную, а x также не определен внутри foo () .

Чтобы это работало, мы используем ключевое слово global . Посетите Python Global Keyword, чтобы узнать больше.

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

Переменная, объявленная внутри тела функции или в локальной области видимости, называется локальной переменной.

Пример 2: Доступ к локальной переменной вне области действия

  def foo ():
    y = "местный"


foo ()
печать (у)  

Выход

  NameError: имя 'y' не определено  

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

Давайте посмотрим на примере создания локальной переменной в Python.

Пример 3: Создание локальной переменной

Обычно мы объявляем переменную внутри функции для создания локальной переменной.

  def foo ():
    y = "местный"
    печать (у)

foo ()  

Выход

  местный  

Давайте посмотрим на более раннюю проблему, где x было глобальной переменной, и мы хотели изменить x внутри foo () .

Глобальные и локальные переменные

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

Пример 4: Использование глобальных и локальных переменных в одном коде

  x = "глобальный"

def foo ():
    глобальный x
    y = "местный"
    х = х * 2
    печать (х)
    печать (у)

foo ()  

Выход

  глобальный глобальный
местный  

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

После вызова foo () значение x становится global global , потому что мы использовали x * 2 , чтобы напечатать два раза global . После этого печатаем значение локальной переменной y , т.е. local .

Пример 5: Глобальная переменная и Локальная переменная с тем же именем

  х = 5

def foo ():
    х = 10
    print ("локальный x:", x)


foo ()
print ("глобальный x:", x)  

Выход

  местное x: 10
глобальный x: 5  

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

Когда мы печатаем переменную внутри foo () , она выводит local x: 10 . Это называется локальной областью действия переменной.

Аналогично, когда мы печатаем переменную вне foo () , она выводит global x: 5 . Это называется глобальной областью видимости переменной.

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

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

Давайте посмотрим на примере использования нелокальной переменной в Python.

Мы используем нелокальных ключевых слов для создания нелокальных переменных.

Пример 6. Создание нелокальной переменной

  def external ():
    x = "местный"

    def inner ():
        нелокальный x
        x = "нелокальный"
        print ("внутренний:", x)

    внутренний()
    print ("внешний:", x)


внешний ()  

Выход

  внутренний: нелокальный
внешний: нелокальный  

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

Примечание : Если мы изменим значение нелокальной переменной, изменения появятся в локальной переменной.

Глобальные переменные c

Присоединяйтесь к Stack Overflow, чтобы учиться, делиться знаниями и строить свою карьеру. Находите централизованный надежный контент и сотрудничайте с помощью технологий, которые вы используете чаще всего.Подключайтесь и обменивайтесь знаниями в едином структурированном и удобном для поиска месте. По-видимому, существует множество различных мнений, начиная от: «Никогда! Всегда инкапсулируйте, даже если это простой макрос! Я считаю, что новичкам важно иметь такую ​​ссылку, но, пожалуйста, не загромождайте ее, если другая существует ответ, который в значительной степени похож на ваш — добавьте комментарий или отредактируйте чей-то ответ. Переменные всегда должны иметь меньшую возможную область действия.

Глобальные переменные c

Переменные, объявленные внутри функции, составного оператора или блока, называются локальными переменными.Если вы попытаетесь использовать эти переменные вне функции, в которой они определены, вы получите сообщение об ошибке. Переменная a, созданная внутри составного оператора или блока i.

извините, что прерывание переменных c глобальным мнением уже обсуждалось Завтра новый день

В компьютерном программировании глобальная переменная — это переменная с глобальной областью видимости, что означает, что она видима и доступна во всей программе, если не затенена. Набор всех глобальных переменных известен как глобальная среда или глобальное состояние.В скомпилированных языках глобальные переменные обычно являются статическими переменными, время существования экстента которых составляет все время выполнения программы, хотя в интерпретируемых языках, включая интерпретаторы командной строки, глобальные переменные обычно выделяются динамически при объявлении, поскольку они не известны заранее. В некоторых языках все переменные являются глобальными или глобальными по умолчанию, тогда как в большинстве современных языков переменные имеют ограниченную область видимости, как правило, лексическую область видимости, хотя глобальные переменные часто доступны путем объявления переменной на верхнем уровне программы.Однако в других языках глобальные переменные не существуют; Как правило, это модульные языки программирования, которые реализуют структуру модуля, или основанные на классах объектно-ориентированные языки программирования, которые реализуют структуру классов. Механизмы взаимодействия с глобальными переменными называются глобальной средой, см. Также механизмы глобального состояния. Парадигма глобальной среды контрастирует с парадигмой локальной среды, где все переменные являются локальными без общей памяти, и поэтому все взаимодействия могут быть преобразованы в передачу сообщений.

24.7.2021

определены вне функции, обычно поверх программы.

C — Правила области применения

Локальные переменные: переменные-параметры и статические локальные переменные доступны только в глобальных функциональных переменных. Нам не нужно беспокоиться о том, чтобы сделать эти типы переменных доступными в других функциях, потому что они не могут быть доступны другим функциям. Если мы определим статические глобальные переменные в верхней части файла программы, все глобальные переменные проверки соединения kenwood th-9000d будут быть доступным для всех функций в файле программы.Все функции в программном файле будут следовать после определения статических глобальных переменных. Следовательно: Все функции в программном файле могут обращаться к статическим глобальным переменным.

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

Локальные, глобальные и статические переменные в C

Домашнее тестирование. Должен выучить! Большие данные.

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

Разница между локальной и глобальной переменной

Область видимости в любом программировании — это область программы, в которой может существовать определенная переменная, и за пределами этой переменной к ней нельзя получить доступ. Давайте разберемся, что такое локальные и глобальные переменные, а также формальные параметры. Переменные, которые являются переменными внутри функции или блока, называются локальными переменными. Они могут использоваться только операторами, которые находятся внутри этой функции или блока кода.Локальные переменные, глобальные, неизвестные функциям, вызывают ошибку из собственной хранимой процедуры. В следующем примере показано, как используются локальные переменные. Здесь все переменные a, b и c являются локальными для основной функции.

В компьютерном программировании глобальная переменная — это переменная с глобальной областью видимости, что означает, что она видима (следовательно, доступна).

Подписаться на RSS

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

КЛЮЧЕВАЯ РАЗНИЦА

Компилятор C распознает переменную как глобальную, а не как локальную, потому что ее объявление находится вне области видимости любой из функций, составляющих.

Что такое переменная?

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

Ваш ответ

В заголовочном файле напишите его с помощью extern.И в глобальной области видимости одного из файлов c объявите его без extern.

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