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

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

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

Область видимости переменных в 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;
}

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

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

Он создал переменную 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;
}

А вот ошибки в строке 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;
}

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

15
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;
}

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

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

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

int main() {

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

    system("pause");
    return 0;
}

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

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

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

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

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, то результатом будет:

You very lucky man!
Process returned 0 (0x0) execution time : 0.010 s
Press any key to continue.

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

You lucky!
Process returned 0 (0x0) execution time : 0.010 s
Press any key to continue.

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

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

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

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

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

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

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

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

string str = "You lucky!";

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

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

You lucky!
Process returned 0 (0x0) execution time : 0.010 s
Press any key to continue.

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

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

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

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

« Цикл do while в C++

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

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