Область видимости в C ++

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

Содержание статьи

Декларативный регион и объем
Глобальный масштаб
Область действия блока
Объем функции
Область перечисления
Область действия класса
Область действия параметра шаблона
Имя Скрытие
Возможность повторения декларации в том же объеме
Область действия пространства имен
Объем в разных частях
Заключение

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

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

#включать
используя пространство имен std;
void fn ()

int var = 3;
если (1 == 1)

cout<

int main ()

fn ();
возврат 0;

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

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

#включать
используя пространство имен std;
void fn ()

int var = 3;
если (1 == 1)

float var = 7.5;
cout<

int main ()

fn ();
возврат 0;

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

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

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

Глобальный масштаб

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

#включать
используя пространство имен std;
float var = 9.4;
int main ()

cout <cout <<::var<<'\n';
возврат 0;

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

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

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

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

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

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

#включать
используя пространство имен std;
int main ()

если (1 == 1)

/ * некоторые утверждения * /
int идент = 5;
cout</ * некоторые утверждения * /

возврат 0;

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

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

#включать
используя пространство имен std;
int main ()

int ID = 8;
если (идентификатор == 8)

cout<
возврат 0;

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

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

#включать
используя пространство имен std;
int main ()

если (1 == 1)

int variab = 15;

cout<возврат 0;

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

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

#включать
используя пространство имен std;
int main ()

для (int i = 0; i<4; ++i)

cout<
cout<возврат 0;

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

Объем функции

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

#включать
#включать
используя пространство имен std;
строка fn (строка str)

char stri [] = "бананы";
/ * другие операторы * /
строка totalStr = str + stri;
return totalStr;

int main ()

строка totStr = fn («ест»);
cout<возврат 0;

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

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

Этикетка

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

#включать
используя пространство имен std;
void fn ()

goto labl;
/ * другие операторы * /
labl: int inte = 2;
cout<
int main ()

fn ();
возврат 0;

Выход 2.

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

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

если (1 == 1)

перечисление a, b, c = b + 2;
cout<

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

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

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

перечисление a = c + 2, b, c;

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

если (1 == 1)

перечисление a, b, c = b + 2;

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

Перечисление с ограничением
Следующее утверждение в порядке:

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

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

если (1 == 1)

enum class nam a, b, c = b + 2;
cout<

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

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

#включать
используя пространство имен std;
// Базовый класс
класс Cla

частный:
int memP = 5;
защищено:
int memPro = 9;
общественность:
void fn ()

cout<
;
// Производный класс
класс DerCla: public Cla

общественность:
int derMem = memPro;
;
int main ()

Cla obj;
объект.fn ();
DerCla derObj;
cout<возврат 0;

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

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

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

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

#включать
используя пространство имен std;
класс Cla

общественность:
статический int const mem = 5;
общественность:
статическая пустота fn ()

cout<
;
int main ()

cout<Cla :: fn ();
возврат 0;

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

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

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

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

шаблон структура возрастов

Т Джон = 11;
U Питер = 12.3;
Т Мэри = 13;
U радость = 14.6;
;

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

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

шаблон void func (T no, U cha, const char * str);

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

#включать
используя пространство имен std;
шаблон класс TheCla

общественность:
T num;
статический U ч;
void func (U cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

статическая пустота веселье (U ch)

если (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

TheCla obj;
объект.число = 12;
объект.func ('$', «500»);
возврат 0;

Имя Скрытие

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

#включать
используя пространство имен std;
void fn ()

int var = 3;
если (1 == 1)

int var = 4;
cout<
cout<
int main ()

fn ();
возврат 0;

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

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

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

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

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

#включать
используя пространство имен std;
void fn (целое число);
void fn (целое число);
void fn (целое число)

cout<
int main ()

fn (5);
возврат 0;

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

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

#включать
используя пространство имен std;
void fn (целое число)

cout<
void fn (номер с плавающей запятой)

cout<
int main ()

fn (5);
float flt = 8.7;
fn (flt);
возврат 0;

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

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

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

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

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

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

Заключение

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