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

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

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

Глобальные переменные
Локальные переменные
Глобальная переменная уступает локальной
Глобальный оператор разрешения

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

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

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

int func () {
    // блок (функция - func)
}

int main() {
    // блок (функция - main)
    for (int i = 0; i < 10; i++) {  
        // блок (цикл - for), также является дочерним блоком функции main
        for (int j = 0; j < 5; j++) {
          // блок (цикл - for), но он еще является и дочерним блоком для первого цикла
        }
    }

    
    system("pause");
    return 0;
}

int func () {

// блок (функция - func)

}

int main() {

// блок (функция - main)

for (int i = 0; i < 10; i++) {

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

for (int j = 0; j < 5; j++) {

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

}

system("pause");

return 0;

}

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

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

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

int main() {
    
    for (int i = 0; i < 10; i++) {  
        int b = i;
        for (int j = 0; j < 5; j++) {
            cout << b + j;  
        }
        cout << j;  // ошибка: так как переменная j была создана в другом блоке
    }
 
    system("pause");
    return 0;
}

int main() {

for (int i = 0; i < 10; i++) {

int b = i;

for (int j = 0; j < 5; j++) {

cout << b + j;

}

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

}

system("pause");

return 0;

}

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

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

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

int global = 5;       // глобальные
int global_too = 10;  // переменные

int summa() {
    cout << global + global_too;  // суммируем числа
}

int main() {
    summa();  // вызываем функцию summa

    system("pause");
    return 0;
}

int global = 5; // глобальные

int global_too = 10; // переменные

int summa() {

cout << global + global_too; // суммируем числа

}

int main() {

summa(); // вызываем функцию summa

system("pause");

return 0;

}

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

area_sea.cpp

Process returned 0 (0x0) execution time : 0.010 s

Press any key to continue.

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

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

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

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

int main() {
    for (int i = 0; i < 2; i++) {
      int b = i;  // локальная переменная (она находится в блоке for)
      cout << b;
    }
    system("pause");
    return 0;
}

int main() {

for (int i = 0; i < 2; i++) {

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

cout << b;

}

system("pause");

return 0;

}

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

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

int summa () {
    cout << cost;  // ошибка
}

int main() {

    int cost = 10;  // переменная созданная в блоке main
     
    summa();

    system("pause");
    return 0;
}

int summa () {

cout << cost; // ошибка

}

int main() {

int cost = 10; // переменная созданная в блоке main

summa();

system("pause");

return 0;

}

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

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

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

string str = "You lucky!";

void message() {
    string str = "You very lucky man!";
    cout << str;
}
void sait_message() {
    cout << str;
}

string str = "You lucky!";

void message() {

string str = "You very lucky man!";

cout << str;

}

void sait_message() {

cout << str;

}

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

message.cpp

You very lucky man!

Process returned 0 (0x0) execution time : 0.010 s

Press any key to continue.

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

sait_message.cpp

You lucky!

Process returned 0 (0x0) execution time : 0.010 s

Press any key to continue.

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

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

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

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

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

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

:: <имя глобальной переменной>

1	:: <имя глобальной переменной>

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

string str = "You lucky!";

void message() {
    string str = "You very lucky man!";
    cout << :: str;  // использовали глобальный оператор разрешения 
}

string str = "You lucky!";

void message() {

string str = "You very lucky man!";

cout << :: str; // использовали глобальный оператор разрешения

}

Получится вот такой результат, если мы вызовем функцию message:

globalnyy_operator_razresheniya.cpp

You lucky!

Process returned 0 (0x0) execution time : 0.010 s

Press any key to continue.

Какие виды переменных использовать

Сегодня мы разобрали, что такое область видимости в C++. Также мы рассмотрели, что такое локальные переменные и глобальные переменные.

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

Тест на тему «Функции в C++»

Попробуй пройти тест. Если ты действительно понял весь материал по данной теме, то ты без труда сможешь набрать 100 из 100. Удачи!

Начать

Вопрос 1

Что такое функция?

A	Блок кода, который можно использовать ограниченное кол-во раз.
B	Это обычный оператор
C	Блок кода, который можно использовать неограниченное кол-во раз.
D	Библиотека

Вопрос 2

Что такое прототип функции?

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

Вопрос 3

Что такое перегрузка функций функции?

A	Это частое использования функций.
B	Это создание функций с одинаковыми именами, но с разными сигнатурами.
C	Отсутствие блока кода в функции.

Вопрос 4

Что такое аргумент функции?

A	Это просто аргумент
B	Это переменная, которая находится в функции
C	Это значение которое можно передать в функцию при ее вызове
D	Это переменная Argument

Вопрос 5

Что включает полное имя функции ?

A	Сигнатуру, Имя функции
B	Значение, Тип возвращаемого значение функции, Название аргументы
C	Имя функции, Переменные находящиеся в функции, Типы аргументов функции
D	Имя функции, Число аргументы, Типы аргументов

Количество оставшихся вопросов: 5.

Мы рады, если вам понравилась данный урок. Если вы хотите оставить свой вопрос, то пишите его в комментариях. Нам будет приятно, если вы поделитесь данной статьей со своими друзьями. Удачи!

« Цикл do while в C++

Функции в C++ »