Zakres w C++

Encja w C++ ma nazwę, którą można zadeklarować i/lub zdefiniować. Deklaracja jest definicją, ale definicja niekoniecznie jest deklaracją. Definicja alokuje pamięć dla nazwanego podmiotu, ale deklaracja może alokować pamięć dla nazwanego podmiotu, ale nie musi. Region deklaratywny to największa część programu, w której obowiązuje nazwa podmiotu (zmienna). Ten region nazywa się zakresem lub potencjalnym zakresem. Ten artykuł wyjaśnia scoping w C++. Ponadto do zrozumienia tego artykułu potrzebna jest podstawowa wiedza w języku C++.

Treść artykułu

Region deklaratywny i zakres
Zakres globalny
Zakres bloku
Zakres funkcji
Zakres wyliczenia
Zakres klasy
Zakres parametrów szablonu
Ukrywanie nazwy
Możliwość powtórzenia deklaracji w tym samym zakresie
Zakres przestrzeni nazw
Zakres w różnych porcjach
Wniosek

Region deklaratywny i zakres

Region deklaratywny to największa część tekstu programu, w której obowiązuje nazwa podmiotu. Jest to region, w którym niekwalifikowana nazwa może być używana (widziana) w odniesieniu do tego samego podmiotu. Rozważ następujący krótki program:

#zawierać
przy użyciu standardowej przestrzeni nazw;
nieważne fn()

int zm = 3;
jeśli (1==1)

Cout<

int main()

fn();
zwróć 0;

Funkcja fn() ma dwa bloki: blok wewnętrzny dla warunku if i blok zewnętrzny dla treści funkcji. Identyfikator var jest wprowadzony i widoczny w zewnętrznym bloku. Widać to również w bloku wewnętrznym, z oświadczeniem cout. Bloki zewnętrzne i wewnętrzne są zarówno zakresem nazwy, var.

Jednak nazwa var może nadal być używana do deklarowania innej jednostki, takiej jak zmiennoprzecinkowa w bloku wewnętrznym. Poniższy kod ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
nieważne fn()

int zm = 3;
jeśli (1==1)

pływak zm = 7.5;
Cout<

int main()

fn();
zwróć 0;

Wyjście to 7.5. W takim przypadku nazwa var nie może już być używana w bloku wewnętrznym w odniesieniu do liczby całkowitej o wartości 3, która została wprowadzona (zadeklarowana) w bloku zewnętrznym. Takie wewnętrzne bloki są określane jako potencjalny zakres dla podmiotów zadeklarowanych w zewnętrznym bloku.

Uwaga: Jednostka tego samego typu, taka jak w bloku zewnętrznym, nadal może być zadeklarowana w bloku wewnętrznym. Jednak w tym przypadku to, co jest ważne w bloku wewnętrznym, to nowa deklaracja i jej znaczenie, podczas gdy stara deklaracja i jej znaczenie poza blokiem wewnętrznym pozostają ważne w bloku zewnętrznym.

Deklaracja o tej samej nazwie w bloku wewnętrznym zwykle zastępuje deklarację o tej samej nazwie poza tym blokiem wewnętrznym. Bloki wewnętrzne mogą zagnieżdżać inne bloki wewnętrzne.

Zakres globalny

Kiedy programista po prostu zaczyna pisać plik, to jest zasięg globalny. Poniższy krótki program ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
pływak zm = 9.4;
int main()

Cout <Cout <<::var<<'\n';
zwróć 0;

Dane wyjściowe to:
9.4
9.4

W tym przypadku deklaratywny region lub zakres dla var zaczyna się od punktu deklaracji dla var i kontynuuje w dół aż do końca pliku (jednostka tłumaczenia).

Blok funkcji main() ma inny zakres; jest to zakres zagnieżdżony dla zakresu globalnego. Aby uzyskać dostęp do jednostki o zasięgu globalnym, z innego zakresu, identyfikator jest używany bezpośrednio lub poprzedzony operatorem rozpoznawania zakresu, :: .

Uwaga: encja main() jest również zadeklarowana w zasięgu globalnym.

Zakres bloku

Instrukcja if, while, do, for lub switch może definiować blok. Takie stwierdzenie jest zdaniem złożonym. Nazwa zmiennej zadeklarowanej w bloku ma zasięg bloku. Jego zakres zaczyna się w miejscu deklaracji i kończy na końcu swojego bloku. Poniższy krótki program ilustruje to dla zmiennej ident:

#zawierać
przy użyciu standardowej przestrzeni nazw;
int main()

jeśli (1==1)

/*niektóre stwierdzenia*/
int ident = 5;
Cout</*niektóre stwierdzenia*/

zwróć 0;

Zmienna, taka jak ident, zadeklarowana w zakresie bloku jest zmienną lokalną.

Zmienną zadeklarowaną poza zakresem bloku i powyżej niego można zobaczyć w nagłówku bloku (e.sol., warunek dla if-block), a także w obrębie bloku. Poniższy krótki program ilustruje to dla zmiennej, identif:

#zawierać
przy użyciu standardowej przestrzeni nazw;
int main()

int identif = 8;
jeśli (identyfikator == 8)

Cout<
zwróć 0;

Wyjście to 8. Są tu dwa zakresy bloków: blok funkcji main() i zagnieżdżona instrukcja if-compound. Zagnieżdżony blok to potencjalny zakres bloku funkcji main().

Deklaracja wprowadzona w zakresie blokowym nie jest widoczna poza blokiem. Poniższy krótki program, który się nie kompiluje, ilustruje to za pomocą zmiennej variab:

#zawierać
przy użyciu standardowej przestrzeni nazw;
int main()

jeśli (1 == 1)

int zmienna = 15;

Cout<zwróć 0;

Kompilator generuje komunikat o błędzie dla zmiennej.

Wprowadzona encja, zadeklarowana w nagłówku funkcji złożonej, nie może być widoczna poza (pod) instrukcją złożoną. Poniższy kod pętli for nie skompiluje się, co spowoduje wyświetlenie komunikatu o błędzie:

#zawierać
przy użyciu standardowej przestrzeni nazw;
int main()

dla (int i=0; i<4; ++i)

Cout<
Cout<zwróć 0;

Zmienna iteracji, i, jest widoczna wewnątrz bloku pętli for, ale nie poza blokiem pętli for.

Zakres funkcji

Parametr funkcji jest widoczny w bloku funkcyjnym. Encja zadeklarowana w bloku funkcyjnym jest widziana od momentu deklaracji do końca bloku funkcyjnego. Poniższy krótki program ilustruje to:

#zawierać
#zawierać
przy użyciu standardowej przestrzeni nazw;
ciąg fn(ciąg ciąg)

char stri[] = "banany";
/*inne stwierdzenia*/
ciąg totalStr = str + stri;
return totalStr;

int main()

string totStr = fn("jedzenie ");
Cout<zwróć 0;

Dane wyjściowe to:
jedzenie bananów

Uwaga: Obiekt zadeklarowany poza funkcją (powyżej) można zobaczyć na liście parametrów funkcji, a także w bloku funkcyjnym.

Etykieta

Zakres etykiety to funkcja, w której się pojawia. Poniższy kod ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
nieważne fn()

przejdź do etykiety;
/*inne stwierdzenia*/
labl: int inte = 2;
Cout<
int main()

fn();
zwróć 0;

Wyjście to 2.

Zakres wyliczenia

Wyliczenie bez zakresu
Rozważ następujący blok if:

jeśli (1==1)

wyliczenie a, b, c=b+2;
Cout<

Wyjście to 0 1 3.

Pierwszy wiersz w bloku to wyliczenie, a, b i c to jego enumeratory. Zakres enumeratora zaczyna się od punktu deklaracji do końca otaczającego bloku wyliczenia.

Poniższa instrukcja nie zostanie skompilowana, ponieważ punkt deklaracji c jest późniejszy niż punkt a:

wyliczenie a=c+2, b, c;

Poniższy segment kodu nie zostanie skompilowany, ponieważ moduły wyliczające są dostępne po bloku obejmującym wyliczenie:

jeśli (1==1)

wyliczenie a, b, c=b+2;

Cout<Powyższe wyliczenie jest opisane jako wyliczenie bez zakresu, a jego moduły wyliczające są opisane jako moduły wyliczające bez zakresu. Dzieje się tak, ponieważ zaczyna się tylko od zastrzeżonego słowa, enum. Wyliczenia, które zaczynają się od klasy enum lub struktury enum, są opisane jako wyliczenia w zakresie. Ich enumeratory są opisane jako enumeratory w zakresie.

Wyliczenie w zakresie
Poniższe stwierdzenie jest w porządku:

wyliczenie klasa nazwa a, b, c=b+2;

To jest przykład wyliczenia w zakresie. Nazwa klasy to nam. Tutaj zakres modułu wyliczającego zaczyna się od punktu deklaracji do końca definicji wyliczenia, a nie od końca bloku otaczającego dla wyliczenia. Poniższy kod nie skompiluje się:

jeśli (1==1)

wyliczenie klasa nazwa a, b, c=b+2;
Cout<

Zakres klasy

Przy normalnym scopingu region deklaratywny zaczyna się od punktu, a następnie kontynuuje i zatrzymuje się w innym punkcie. Zakres istnieje w jednym ciągłym regionie. Dzięki klasie zakres jednostki może znajdować się w różnych regionach, które nie są ze sobą połączone. Nadal obowiązują zasady dotyczące bloków zagnieżdżonych. Poniższy program ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
//Klasa bazowa
klasa Cla

prywatny:
wewn memP = 5;
chroniony:
wewn memPro = 9;
publiczny:
nieważne fn()

Cout<
;
//Klasy pochodnej
klasa DerCla: publiczne Cla

publiczny:
int derMem = memPro;
;
int main()

Cla obj;
obiekt.fn();
DerCla derObj;
Cout<zwróć 0;

Dane wyjściowe to:
5
9

W klasie Cla zmienna memP jest widoczna w punkcie deklaracji. Następnie krótki fragment słowa „chroniony” jest pomijany, a następnie ponownie widziany w bloku funkcyjnym elementu klasy. Klasa pochodna jest pomijana, a następnie ponownie widziana w zakresie (bloku) funkcji main().

W klasie Cla zmienna memPro jest widoczna w punkcie deklaracji. Część funkcji publicznej fn() jest pomijana, a następnie widoczna w bloku opisu klasy pochodnej. Widać to ponownie w funkcji main().

Operator Rozdzielczości Zakresu
Operatorem rozpoznawania zakresu w C++ jest :: . Służy do uzyskiwania dostępu do statycznego członka klasy. Poniższy program ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
klasa Cla

publiczny:
static int const mem = 5;
publiczny:
pustka statyczna fn()

Cout<
;
int main()

Cout<Cla::fn();
zwróć 0;

Dane wyjściowe to:
5
5

Elementy statyczne są widoczne w bloku funkcji main(), do którego dostęp uzyskuje się za pomocą operatora rozpoznawania zakresu.

Zakres parametrów szablonu

Normalny zakres nazwy parametru szablonu zaczyna się od momentu deklaracji do końca jej bloku, jak w poniższym kodzie:

szablon struktura Wieki

T Jan = 11;
U Piotra = 12.3;
T Mary = 13;
Radość = 14.6;
;

U i T są widoczne w bloku.

W przypadku prototypu funkcji szablonu zakres zaczyna się od punktu deklaracji do końca listy parametrów funkcji, jak w poniższej instrukcji:

szablon void func (T no, U cha, const char *str );

Natomiast jeśli chodzi o opis klasy (definicję), to zakres może składać się również z różnych części, jak w poniższym kodzie:

#zawierać
przy użyciu standardowej przestrzeni nazw;
szablon klasa TheCla

publiczny:
liczba T;
statyczny Uch;
void func (U cha, const char *str)

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

pustka statyczna zabawa (U ch)

jeśli (ch == 'a')
Cout << "Official static member function" << '\n';

;
int main()

TheCla przedmiot;
obiekt.liczba = 12;
obiekt.func('$', "500");
zwróć 0;

Ukrywanie nazwy

Przykład ukrywania nazw występuje, gdy nazwa tego samego typu obiektu jest ponownie zadeklarowana w zagnieżdżonym bloku. Poniższy program ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
nieważne fn()

int zm = 3;
jeśli (1==1)

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

fn();
zwróć 0;

Dane wyjściowe to:
4
3

Dzieje się tak, ponieważ zmienna w bloku zagnieżdżonym ukryła zmienną w bloku zewnętrznym outer.

Możliwość powtórzenia deklaracji w tym samym zakresie

Punktem deklaracji jest wprowadzenie nazwy (po raz pierwszy) w jej zakresie.

Prototyp funkcji
Różne encje, nawet różnych typów, nie mogą być normalnie deklarowane w tym samym zakresie. Jednak prototyp funkcji można zadeklarować więcej niż raz w tym samym zakresie. Poniższy program z dwoma prototypami funkcji i odpowiednią definicją funkcji ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
void fn(liczba int);
void fn(liczba int);
nieważne fn(liczba wewnętrzna)

Cout<
int main()

fn(5);
zwróć 0;

Program działa.

Przeciążone funkcje
Przeciążone funkcje to funkcje o tej samej nazwie, ale o różnych sygnaturach. W ramach innego wyjątku przeciążone funkcje o tej samej nazwie można zdefiniować w tym samym zakresie. Poniższy program ilustruje to:

#zawierać
przy użyciu standardowej przestrzeni nazw;
nieważne fn(liczba wewnętrzna)

Cout<
void fn (liczba zmiennoprzecinkowa nie)

Cout<
int main()

fn(5);
pływak flt = 8.7;
fn(flt);
zwróć 0;

Dane wyjściowe to:
5
8.7

Przeciążone funkcje zostały zdefiniowane w zasięgu globalnym.

Zakres przestrzeni nazw

Zakres przestrzeni nazw zasługuje na swój własny artykuł. Wspomniany artykuł został napisany dla tej witryny, linuxhint.com. Wystarczy wpisać wyszukiwane słowa „Zakres przestrzeni nazw” w polu wyszukiwania tej witryny (strony) i kliknąć OK, a otrzymasz artykuł.

Zakres w różnych porcjach

Klasa nie jest jedynym schematem, w którym zakres może być w różnych częściach. Specyfikator zaprzyjaźniony, niektóre zastosowania specyfikatora-opracowanego typu i dyrektywy using to inne schematy, w których zakres znajduje się w różnych miejscach - po szczegóły, zobacz dalej.

Wniosek

Zakres jest regionem deklaratywnym. Region deklaratywny to największa część tekstu programu, w której obowiązuje nazwa podmiotu. Można go podzielić na więcej niż jedną część zgodnie z pewnymi schematami programowania, takimi jak zagnieżdżone bloki. Części, które nie mają punktu deklaracji, tworzą potencjalny zakres. Potencjalny zakres może, ale nie musi mieć deklaracji.