Все глобальные переменные cpp

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

Глобальные объекты

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

Если глобальные переменные не инициализированы, то они получают нулевые значения.

Например, определим и используем глобальную переменную:

#include int n; // глобальная переменная void print() < n++; std::cout int main() < print(); // n=6 n++; std::cout локальными. Такие объекты доступны в пределах только того блока кода, в котором они определены.

Автоматические объекты

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

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

#include void print() < int n ; // локальная переменная, которая существует только в функции print std::cout int main() < int m ; // локальная переменная, которая существует только в функции main std::cout #include int main() < int n1 ; // область видимости - вся функция main < int n2 ; // область видимости - блок кода std::cout // конец блока функции - конец времени жизни переменной n2 // так нельзя - переменная n2 из блока функции уже не существует // std::cout #include int n ; int main() < int n ; std::cout ; std::cout n. Переменная n, определенная на уровне функции main (int n = 10;) скрывает глобальную переменную n. А переменная n, определенная на уровне блока, скрывает переменную, определенную на уровне функции main.

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

#include int n ; int main() < int n ; std::cout ; std::cout static. Если автоматические переменные определяются и инициализируются при каждом входе в функцию, то статические переменные инициализируются только один раз, а при последующих вызовах функции используется старое значение статической переменной. То есть разница между локальными автоматическими и локальными статическими переменными состоит во времени жизни: автоматические переменные существуют до конца выполнения блока кода, а статические - до конца выполнения программы.

Например, пусть у нас будет функция со стандартной автоматической переменной:

#include void print() < int n ; std::cout

n=1 n=1 n=1

Теперь сделаем переменную n статической:

#include void print() < static int n ; std::cout

n=1 n=2 n=3

Источник

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

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

Существуют локальные и глобальные переменные. Так вот, переменные, объявленные внутри функции, называются локальными. Локальные переменные имеют свои области видимости, этими областями являются функции, в которых объявлены переменные. Таким образом, в разных функциях можно использовать переменные с одинаковыми именами, что в свою очередь очень удобно. Разделение переменных на глобальные и локальные соответствует одному из главных правил программирования, а именно – принципу наименьших привилегий. То есть, переменные, объявленные внутри одной функции, должны быть доступны только для этой функции и ни чему другому, в конце концов, они создавались именно для этой функции. Глобальные переменные объявляются вне тела какой-либо функции, и поэтому область видимости таких переменных распространяется на всю программу. Обычно глобальные переменные объявляются перед главной функцией, но можно объявлять и после функции main() , но тогда данная переменная не будет доступна в функции main() .

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

// variables.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; void example(); int variable = 48; // инициализация глобальной переменной int main(int argc, char* argv[]) < int variable = 12; // инициализация локально переменной cout void example() < cout

// variables.cpp: определяет точку входа для консольного приложения. #include using namespace std; void example(); int variable = 48; // инициализация глобальной переменной int main(int argc, char* argv[]) < int variable = 12; // инициализация локально переменной cout void example() < cout

В строках 8 и 12 объявлены переменные одинакового типа с одним и тем же именем variable , но переменная в строке 8 является глобальной переменной, а переменная в строке 12 — это локальная переменная. Функция example() имеет доступ только к глобальной переменной. В то время как функция main() имеет доступ как к локальной так и к глобальной переменным. Если в области видимости есть и локальная и глобальная переменные с одинаковыми именами, то при обращении к ним, будет использоваться ближайшая переменная, а это локальная переменная, это видно по результату работы программы (см. Рисунок 1).

local variable = 12 global variable = 48

Рисунок 1 — Локальные и глобальные переменные в С++

Как мы уже сказали, функция main() имеет доступ и к глобальной переменной, но не показали, как получить этот доступ. В С++ существует такая операция, как разрешение области действия :: . Эта операция позволяет обращаться к глобальной переменной из любого места программы.» Все, что нужно сделать, так это поставить двойное двоеточие перед именем переменной. Ниже показан код, верхней программы с одним лишь изменением, и это изменение – операция разрешения доступа в строке 13.

// variables.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; void example(); int variable = 48; // инициализация глобальной переменной int main(int argc, char* argv[]) < int variable = 12; // инициализация локально переменной cout void example() < cout

// variables.cpp: определяет точку входа для консольного приложения. #include using namespace std; void example(); int variable = 48; // инициализация глобальной переменной int main(int argc, char* argv[]) < int variable = 12; // инициализация локально переменной cout void example() < cout

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

local variable = 48 global variable = 48

Рисунок 2 — Локальные и глобальные переменные в С++

К сожалению, для данной темы пока нет подходящих задач. Если у вас есть таковые на примете, отправте их по адресу: admin@cppstudio.com. Мы их опубликуем!

Источник

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

Всем привет! Сегодня мы затронем тему, которую должны были изучить еще в самом начале пути изучения C++ — область видимости переменных. Мы разберем, что такое локальные и глобальные переменные.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В примере выше блоком где была создана локальная переменная b является цикл for (2 — 5). А вот если бы мы захотели вывести переменную b вне блока for , компилятор сообщил бы нам об ошибке, подробнее об этом говорится ниже.

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

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

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

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

Мы создали глобальную переменную str со значением «You lucky!» и локальную переменную с таким же названием в функции message , но с другим значением — «You very lucky man!». Если мы вызовем функцию message , то результатом будет:

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

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

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

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

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

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

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

Источник