Обхват в C ++

Обект в C ++ има име, което може да бъде декларирано и / или дефинирано. Декларацията е дефиниция, но дефиницията не е непременно декларация. Дефиницията разпределя памет за посочения обект, но декларацията може или не може да разпредели памет за посочения обект. Декларативният регион е най-голямата част от програма, в която е валидно името на обект (променлива). Този регион се нарича обхват или потенциален обхват. Тази статия обяснява обхвата в C++. Освен това са необходими основни познания по C ++, за да се разбере тази статия.

Съдържание на статията

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

Декларативен регион и обхват

Декларативният регион е най-голямата част от програмния текст, в който е валидно името на обект. Това е регионът, в който неквалифицираното име може да се използва (вижда се), за да се отнася към същия обект. Обмислете следната кратка програма:

#include
използване на пространство от имена std;
void fn ()

int var = 3;
ако (1 == 1)

Cout<

int main ()

fn ();
връщане 0;

Функцията fn () има два блока: вътрешен блок за условието if и външен блок за тялото на функцията. Идентификаторът var се въвежда и вижда във външния блок. Вижда се и във вътрешния блок, с изявлението cout. Външният и вътрешният блок са обхватът на името, var.

Името, var, все още може да се използва за деклариране на различен обект, като плувка във вътрешния блок. Следният код илюстрира това:

#include
използване на пространство от имена std;
void fn ()

int var = 3;
ако (1 == 1)

float var = 7.5;
Cout<

int main ()

fn ();
връщане 0;

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

Забележка: Обект от същия тип, като този на външния блок, все още може да бъде деклариран във вътрешния блок. В този случай обаче това, което е валидно във вътрешния блок, е новата декларация и нейното значение, докато старата декларация и нейното значение извън вътрешния блок остават валидни във външния блок.

Декларация със същото име във вътрешен блок обикновено заменя декларацията със същото име извън този вътрешен блок. Вътрешните блокове могат да влагат други вътрешни блокове.

Глобален обхват

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

#include
използване на пространство от имена std;
float var = 9.4;
int main ()

Cout <Cout <<::var<<'\n';
връщане 0;

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

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

Блокът на функцията main () е различен обхват; това е вложен обхват за глобалния обхват. За достъп до обект от глобалния обхват, от различен обхват, идентификаторът се използва директно или предшестван от оператора за разрешаване на обхвата, .

Забележка: Обектът main () също е деклариран в глобалния обхват.

Блок обхват

Операторът if, while, do, за или switch може да дефинира всеки блок. Такова изявление е сложно изявление. Името на променлива, декларирана в блок, има обхват на блока. Обхватът му започва в точката на деклариране и завършва в края на блока. Следващата кратка програма илюстрира това за променливата id:

#include
използване на пространство от имена std;
int main ()

ако (1 == 1)

/ * някои твърдения * /
int ident = 5;
Cout</ * някои твърдения * /

връщане 0;

Променлива, като ident, декларирана в обхвата на блока, е локална променлива.

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

#include
използване на пространство от имена std;
int main ()

int identif = 8;
ако (идентификация == 8)

Cout<
връщане 0;

Изходът е 8. Тук има два обхвата на блоковете: блокът за функцията main () и вложеният оператор if-complex. Вложеният блок е потенциалният обхват на основния () функционален блок.

Декларация, въведена в обхват на блок, не може да се види извън блока. Следващата кратка програма, която не се компилира, илюстрира това с променливата, variab:

#include
използване на пространство от имена std;
int main ()

ако (1 == 1)

int variab = 15;

Cout<връщане 0;

Компилаторът създава съобщение за грешка за variab.

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

#include
използване на пространство от имена std;
int main ()

за (int i = 0; i<4; ++i)

Cout<
Cout<връщане 0;

Променливата за итерация, i, се вижда вътре в блока за цикъл, но не и извън блока за цикъл.

Функция Обхват

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

#include
#include
използване на пространство от имена std;
низ fn (низ str)

char stri [] = "банани";
/ * други изявления * /
низ totalStr = str + stri;
върнете totalStr;

int main ()

низ totStr = fn („ядене“);
Cout<връщане 0;

Резултатът е:
ядене на банани

Забележка: Обект, деклариран извън функцията (над нея), може да се види в списъка с параметри на функцията, а също и във функционалния блок.

Етикет

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

#include
използване на пространство от имена std;
void fn ()

отидете labl;
/ * други изявления * /
labl: int inte = 2;
Cout<
int main ()

fn ();
връщане 0;

Изходът е 2.

Обхват на изброяване

Нескопирано изброяване
Обмислете следния if-block:

ако (1 == 1)

преброяване a, b, c = b + 2;
Cout<

Изходът е 0 1 3.

Първият ред в блока е изброяване, a, b и c са неговите изброители. Обхватът на изброител започва от точката на деклариране до края на заграждащия блок на изброяването.

Следното изявление няма да се компилира, защото точката на деклариране на c е след тази на a:

enum a = c + 2, b, c;

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

ако (1 == 1)

преброяване a, b, c = b + 2;

Cout<Горното изброяване е описано като неразпределено изброяване, а неговите изброители са описани като неразпределени изброители. Това е така, защото започва само със запазената дума, enum. Изброяванията, които започват с enum class или enum struct се описват като обхватни изброявания. Техните изброители са описани като обхватни преброители.

Обхватно изброяване
Следното твърдение е наред:

enum клас nam a, b, c = b + 2;

Това е пример за изброяване в обхват. Името на класа е nam. Тук обхватът на изброителя започва от точката на декларация до края на дефиницията на изброяване, а не в края на заграждащия блок за изброяването. Следният код няма да се компилира:

ако (1 == 1)

enum клас nam a, b, c = b + 2;
Cout<

Обхват на класа

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

#include
използване на пространство от имена std;
// Базов клас
клас Кла

частно:
int memP = 5;
защитени:
int memPro = 9;
публично:
void fn ()

Cout<
;
// Производен клас
клас DerCla: публичен Cla

публично:
int derMem = memPro;
;
int main ()

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

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

В класа Cla променливата memP се вижда в точката на деклариране. След това кратката част от „protected“ се пропуска, след което се вижда отново във функционалния блок на члена на класа. Полученият клас се пропуска, след което се вижда отново в обхвата на функцията main () (блок).

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

Оператор за разрешаване на обхват
Операторът за разделителна способност в C ++ е :: . Използва се за достъп до статичен член на класа. Следващата програма илюстрира това:

#include
използване на пространство от имена std;
клас Кла

публично:
статичен int const mem = 5;
публично:
статична празнота fn ()

Cout<
;
int main ()

Cout<Cla :: fn ();
връщане 0;

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

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

Обхват на параметър на шаблона

Нормалният обхват на името на параметъра на шаблона започва от точката на декларация до края на неговия блок, както е в следния код:

шаблон struct Ages

T Йоан = 11;
U Петър = 12.3;
T Мери = 13;
U Радост = 14.6;
;

U и T се виждат в блока.

За прототип на шаблонна функция обхватът започва от точката на декларация до края на списъка с параметри на функцията, както е в следния израз:

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

Когато става въпрос за описание на класа (дефиниция), обхватът също може да бъде от различни части, както в следния код:

#include
използване на пространство от имена std;
шаблон клас TheCla

публично:
T номер;
статичен U ch;
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;
обект.num = 12;
обект.func ('$', "500");
връщане 0;

Скриване на име

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

#include
използване на пространство от имена std;
void fn ()

int var = 3;
ако (1 == 1)

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

fn ();
връщане 0;

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

Това е така, защото var в вложения блок е скрил var във външния блок.

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

Смисълът на декларацията е мястото, където името се въвежда (за първи път) в обхвата си.

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

#include
използване на пространство от имена std;
void fn (int num);
void fn (int num);
void fn (int num)

Cout<
int main ()

fn (5);
връщане 0;

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

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

#include
използване на пространство от имена std;
void fn (int num)

Cout<
void fn (float no)

Cout<
int main ()

fn (5);
float flt = 8.7;
fn (flt);
връщане 0;

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

Претоварените функции са дефинирани в глобалния обхват.

Обхват на пространството от имена

Пространството от имена Scope заслужава собствена статия. Споменатата статия е написана за този уебсайт, linuxhint.com. Просто въведете думите за търсене „Обхват на пространството от имена“ в полето за търсене на този сайт (страница) и щракнете върху OK и ще получите статията.

Обхват в различни порции

Класът не е единствената схема, при която обхватът може да бъде на различни порции. Спецификатор на приятел, определени употреби на разработения тип-спецификатор и директиви за използване са други схеми, при които обхватът е на различни места - за подробности вижте по-късно.

Заключение

Обхватът е декларативен регион. Декларативният регион е най-голямата част от текста на програмата, в която е валидно името на обект. Той може да бъде разделен на повече от една част в съответствие с определени схеми за програмиране, като вложени блокове. Частите, които нямат декларационната точка, формират потенциалния обхват. Потенциалният обхват може или не може да съдържа декларацията.