Съдържание

  1. Локални и нелокални променливи
  2. Глобални променливи
  3. Скрити променливи
  4. Недостъпни променливи

 

Увод

По областта си на действие идентификаторите/променливите се разделят на локални, нелокални и глобални. Една променлива може да се достъпи, само ако е в рамките на нейната област.

Локални и нелокални променливи

Това са променливите, които са декларирани в даден блок – те са локални за него. Областта им на действие започва с тяхното деклариране и завършва в края на блока. Локалните променливи могат да бъдат достъпни и за други блокове, които се намират в техният блок на действие – тогава те се наричат нелокални за този вътрешен блок. Пример:

  1. #include <iostream>
  2. using namespace std;
  3. int main(){
  4.      int y = 100; // Локална променлива за фукцията main
  5.      cout <<y<<endl; // Ще принтира 100
  6.      { // Нов блок
  7.      int x = 10; // Локална променлива за този вътрешен блок
  8.     cout << x << endl; // Ще принтира 10
  9.     y = y + 1;
  10.     cout << y <<endl; // y e нелокална за този блок и ще принтира 101
  11.     } // Край на новия блок
  12.     cout << x << endl; // Тук ще изведе грешка, тъй като x не e достъпна за блока на main
  13.     cout << y << endl; // y сега ще е 101 тъй като я променихме в блокът
  14.     return 0;
  15. } // край на main

Разяснение: В главната функция(main) се декларират 2 променливи y и x, y е локална за блока на главната функция и нелокална за съдържащия се в него вътрешен блок. Променливата х е локална за вътрешния блок и недостъпна извън него(в main).

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

Глобалните променливи се декларират извън всички блокове. Тяхното действие започва с декларирането и завършва в края на файла. Пример:

  1. #include <iostream>
  2. using namespace std;
  3. int global = 10;
  4. int main(){
  5.      int local = 100;
  6.      cout << local << endl; // Ще принтира 100
  7.      cout << global << endl; // Ще принтира 10
  8.      return 0;
  9. }

 

Скрити променливи

В рамките на един и същи блок не се допуска да има повече от една променлива с даден идентификатор, но е възможно две променливи от различни блокове да имат един и същ идентификатор. Какво става обаче, когато областа на действие на една променлива е част от областа на действие на друга променлива и идентификаторите им са еднакви? Решението в случая на C++ е, че винаги локалната променлива е с приоритет пред нелокалната (или глобалната). Пример:

  1. #include <iostream>
  2. using namespace std;
  3. int y = 1; // Глобална променлива
  4. int main(){
  5.      int y = 10; // Локална променлива за фукцията main (със същият идентификатор като глобалната)
  6.      cout << y << endl; // Ще принтира 10
  7.      { //Нов блок
  8.     int y = 100;
  9.     cout << y << endl; // Ще принтира 100 тъй като локалната променлива у = 100
  10.     } //Край на новия блок
  11.     cout << y << endl; // y сега ще е 10 тъй като тук локалната промелива e у = 10
  12.     return 0;
  13. }

 

Недостъпни променливи

Променлива, декларирана в даден блок, който няма нищо общо с друг блок, е локална за този, в който е декларирана и недостъпна за другия. Пример:

  1. #include <iostream>
  2. using namespace std;
  3. int main(){
  4.      int a = 10;
  5.      cout << a << endl;
  6.      return 0;
  7. }
  8. void func(){
  9. int a = 101;
  10. cout << a << endl; // ще принтира 101
  11. }

Ако се опитаме да използваме променлива, която е недостъпна за даден блок, компилаторът ще изведе грешка по време на компилация.

  1. #include <iostream>
  2. using namespace std;
  3. int ret();
  4. int main(){
  5.      int a = 10;
  6.      cout<< ret() <<endl;
  7.      return 0;
  8. }
  9. int ret() //Тази функция ще се опита да добави 1 към а
  10. {
  11. return ++a;
  12. }

 

‘a’ was not declared in this scope|
а не е декларирана в този блок.

Автор: SYNCHRO