Zakres w C ++

Jednostka w C ++ ma nazwę, którą można zadeklarować i/lub zdefiniować. Deklaracja jest definicją, ale definicja niekoniecznie jest deklaracją. Definicja przydziela pamięć dla wymienionego bytu, ale deklaracja może, ale nie musi przydzielić pamięci dla nazwanej jednostki. Region deklaracji jest największą częścią programu, w którym nazwa jednostki (zmienna) jest ważna. Ten region nazywa się zakresem lub potencjalnym zakresem. W tym artykule wyjaśniono zakres w C++. Ponadto, podstawowa wiedza na temat C ++ jest wymagana do zrozumienia tego artykułu.

Treść artykułu

• Region deklaracji i zakres
• Zakres globalny
• Zmienne globalne i globalny zakres
• Zakres bloków
• Zakres funkcji
• Zakres klasowy
• Zakres wyliczenia
• Zmienna globalna
• Szablon zakres parametrów
• Ukrywa się nazwisko
• Możliwość powtórzenia deklaracji w tym samym zakresie
• Zakres przestrzeni nazw
• Zakres w różnych porcjach
• Wniosek

Region deklaracji i zakres

Region deklaratywny jest największą częścią tekstu programu, w którym nazwa jednostki jest ważna. Region, w którym można użyć niekwalifikowanej nazwy (widocznej) w odniesieniu do tego samego bytu. Rozważ następujący krótki program:

#włączać
za pomocą przestrzeni nazw Std;
void fn ()

int var = 3;
if (1 == 1)

Cout<

int main ()

fn ();
powrót 0;

Funkcja fn () ma dwa bloki: blok wewnętrzny dla klimatu IF i blok zewnętrzny dla ciała funkcyjnego. Identyfikator, var, jest wprowadzany i widoczny w bloku zewnętrznym. Jest to również widoczne w bloku wewnętrznym, z instrukcją Cout. Bloki zewnętrzne i wewnętrzne są zakresem nazwy, var.

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

#włączać
za pomocą przestrzeni nazw Std;
void fn ()

int var = 3;
if (1 == 1)

float var = 7.5;
Cout<

int main ()

fn ();
powrót 0;

Wyjście jest

7.5

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

Uwaga: jednostka tego samego typu, podobnie jak blok zewnętrzny, może być nadal zadeklarowany w bloku wewnętrznym. Jednak w tym przypadku nowa deklaracja i jej znaczenie są ważne w bloku wewnętrznym, podczas gdy stara deklaracja i znaczenie poza blokiem wewnętrznym pozostają ważne tylko w bloku zewnętrznym.

Deklaracja tej samej nazwy w bloku wewnętrznym zwykle zastępuje deklarację tej samej nazwy na zewnątrz, że blok wewnętrzny. Bloki wewnętrzne mogą gniazdować inne bloki wewnętrzne.

Zakres globalny

Kiedy programista zaczyna pisać plik, to jest globalny zakres. Poniższy krótki program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
float var = 9.4;
int main ()

Cout <Cout <<::var<<'\n';
powrót 0;

Wyjście to:

9.4
9.4

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

Blok funkcji main () jest inny zakres; jest to zagnieżdżony zakres globalnego zakresu. Aby uzyskać dostęp do jednostki globalnej z innego zakresu, identyfikator jest używany bezpośrednio lub poprzedzony przez operatora rozdzielczości zakresu :: .

Uwaga: jednostka, main (), jest również zadeklarowana w globalnym zakresie.

Zakres bloków

If, podczas gdy instrukcje dla lub przełączników mogą zdefiniować blok. Takie stwierdzenie jest złożonym stwierdzeniem. Nazwa zmiennej zadeklarowanej w bloku ma zakres bloku. Jego zakres rozpoczyna się w punkcie deklaracji i kończy się na końcu bloku. Poniższy krótki program ilustruje to dla zmiennej, identyfikator:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

if (1 == 1)

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

powrót 0;

Zmienna, taka jak tożsamość, zadeklarowana w zakresie bloków, jest zmienną lokalną.

Zmienna zadeklarowana poza zakresem bloku i powyżej można zobaczyć w nagłówku bloku (e.G., warunek dla bloku if) i w bloku. Poniższy krótki program ilustruje to dla zmiennej, identyfikator:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

int identyf = 8;
if (identyf == 8)

Cout<
powrót 0;

Wyjście jest,

8

Istnieją dwa rozszczepienia blokowe: blok funkcji main () i zagnieżdżone instrukcja if-powół. Blok zagnieżdżony jest potencjalnym zakresem bloku funkcyjnego Main ().

Deklaracji wprowadzonej w zakresie bloków nie można zobaczyć poza blokiem. Poniższy krótki program, który nie kompiluje, ilustruje to ze zmienną, Variab:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

if (1 == 1)

int variab = 15;

Cout<powrót 0;

Kompilator tworzy komunikat o błędzie dla Variab.

Podmiot wprowadzony, zadeklarowany w nagłówku funkcji złożonej, nie można zobaczyć na zewnątrz (poniżej) stwierdzenie złożonego. Poniższy kod do pętli nie zostanie skompilowany, co spowoduje komunikat o błędzie:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

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

Cout<
Cout<powrót 0;

Zmienna iteracja, i, jest widoczna wewnątrz bloku na pętlę, ale nie poza blokiem pętli.

Zakres funkcji

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

#włączać
#włączać
za pomocą przestrzeni nazw Std;
String fn (string str)

char stri [] = „banany”;
/*Inne stwierdzenia*/
String Totalstr = Str + Stri;
powrót Totalstr;

int main ()

String totstr = fn („jedzenie”);
Cout<powrót 0;

Wyjście to:

Jedzenie bananów

Uwaga: Entity zadeklarowany poza funkcją (powyżej) można zobaczyć na liście parametrów funkcji i bloku funkcji.

Etykieta

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

#włączać
za pomocą przestrzeni nazw Std;
void fn ()

Goto Labl;
/*Inne stwierdzenia*/
labl: int inte = 2;
Cout<
int main ()

fn ();
powrót 0;

Wyjście jest

2

Zakres klasowy

Przy normalnym zakresie, region deklaratywny zaczyna się od jednego punktu w programie, kontynuuje i zatrzymuje się w innym punkcie. Zakres istnieje w jednym regionie ciągłym. Z klasą zakres jednostki może znajdować się w różnych regionach, które nie są połączone. Nadal obowiązują zasady zagnieżdżonych bloków. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
// klasa podstawowa
CLA CLA

prywatny:
int memp = 5;
chroniony:
int mempro = 9;
publiczny:
void fn ()

Cout<
;
//Klasy pochodnej
klasa dercla: publiczne CLA

publiczny:
int dermem = mempro;
;
int main ()

Cla Obj;
obj.fn ();
Dercla derobj;
Cout<powrót 0;

Wyjście to:

5
9

W klasie CLA zmienna MEMP jest widoczna w punkcie deklaracji. Następnie krótka część „chronionych” jest pomijana i widoczna ponownie w bloku funkcji członka klasy. Klasa pochodna jest pomijana i widoczna ponownie w zakresie funkcji Main () (blok).

W klasie CLA zmienna, Mempro, jest widoczna w punkcie deklaracji. Część funkcji publicznej FN () jest pomijana, a następnie widoczna w bloku opisu pochodnej klasy. Jest to ponownie widoczne w funkcji Main ().

Operator rozdzielczości zakresu

Operator rozdzielczości zakresu w C ++ to :: . Służy do dostępu do statycznego członka klasy. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
CLA CLA

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

Cout<
;
int main ()

Cout<Cla :: fn ();
powrót 0;

Wyjście to:

5
5

Członkowie statyczne są widoczne w bloku funkcyjnym Main (), dostępnym za pomocą operatora rozdzielczości zakresu.

Zakres wyliczenia

Uncoped Eumeration

Rozważ następujące if-block:

if (1 == 1)

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

Wyjście to:

0 1 3

Pierwsza linia w bloku jest wyliczeniem; A, B i C są jego wyliczającymi. Zakres wyliczenia rozpoczyna się od punktu jego deklaracji, do końca otaczającego bloku wyliczenia.

Poniższe stwierdzenie nie zostanie skompilowane, ponieważ punkt deklaracji C jest po punkcie A:

enum a = c+2, b, c;

Poniższy segment kodu nie zostanie skompilowany, ponieważ do wyliczenia są dostępne po zamknięciu bloku wyliczenia:

if (1 == 1)

enum a, b, c = b+2;

Cout<

Poprzednie wyliczenie jest opisywane jako wyliczenie odszkodowane, a jego wyliczniki są zdefiniowane jako wyliczane. Dzieje się tak, ponieważ zaczyna się tylko od zastrzeżonego słowa, enum. Wyliczenia, które rozpoczynają się od klasy enum lub struktury enum, są opisane jako wyliczenia rozstrzygnięte. Ich wyliczające są zdefiniowane jako wykrzywione odliczające.

Zakopiowane wyliczenie

Poniższe stwierdzenie jest OK:

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

To jest przykład rozliczonego wyliczenia. Nazwa klasy to Nam. Tutaj zakres wyliczenia rozpoczyna. Poniższy kod nie skompiluje:

if (1 == 1)

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

Proste użycie ustalonego wyliczenia

Poniższy kod pokazuje prosty sposób korzystania z wyliczenia Scoped:

if (1 == 1)

enum Nam a, b, c = b+2;
Cout << c << endl; //simple usage

Wyjście to 3, ponieważ B to 1 („A” to 0).

Zmienna globalna

Zmienna globalna to zmienna zadeklarowana w zakresie globalnym. Kiedy programista zaczyna pisać plik, to jest globalny zakres. Rozważ następujący program:

#włączać
za pomocą przestrzeni nazw Std;
char va = „a”;
int main ()

Cout <Cout <<::va<<'\n';
powrót 0;

Wyjście to:

A
A

W tym programie część lub zakres VA rozpoczyna się od punktu deklaracji VA i trwa w dół do końca jednostki tłumaczenia (plik).

Ciało funkcji Main () jest sam w sobie inny zakres; Globalny zakres gniazduje zakres funkcji Main ().

Zmienna VA jest globalną zmienną zakresu lub po prostu zmienną globalną, ponieważ można ją zobaczyć wszędzie w pliku, poczynając od miejsca, w którym została zadeklarowana. Można to zobaczyć w zakresie funkcji main ().

Aby uzyskać dostęp do zmiennej globalnej (zmienna globalnego zakresu) z innego zakresu, nazwa zmiennej jest używana bezpośrednio lub poprzedzona przez operatora rozdzielczości zakresu :: Jak pokazano w powyższym programie.

If, podczas gdy instrukcja, dla lub przełącznika może zdefiniować blok. Takie stwierdzenie jest złożonym stwierdzeniem. Nazwa zmiennej zadeklarowanej w bloku ma zakres bloku. Jego zakres rozpoczyna się w punkcie deklaracji i kończy się na końcu bloku. Poniższy krótki program ilustruje to dla zmiennej, identyfikator:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

if (1 == 1)

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

powrót 0;

Zmienna, taka jak tożsamość, zadeklarowana w zakresie bloków, jest zmienną lokalną.

Zmienna zadeklarowana poza zakresem bloku i powyżej można zobaczyć w nagłówku bloku (e.G., warunek dla bloku if) i w bloku. Poniższy krótki program ilustruje to dla zmiennej, identyfikator:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

int identyf = 8;
if (identyf == 8)

Cout<
powrót 0;

Wyjście jest,

8

Istnieją tutaj dwa rozszczepienia blokowe: blok dla funkcji main () i zagnieżdżone instrukcja if-powół. Blok zagnieżdżony jest potencjalnym zakresem bloku funkcyjnego Main ().

Deklaracji wprowadzonej w zakresie bloków nie można zobaczyć poza blokiem. Poniższy krótki program, który nie kompiluje, ilustruje to ze zmienną, Variab:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

if (1 == 1)

int variab = 15;

Cout<powrót 0;

Kompilator tworzy komunikat o błędzie dla Variab.

Podmiot wprowadzony, zadeklarowany w nagłówku funkcji złożonej, nie można zobaczyć na zewnątrz (poniżej) stwierdzenie złożonego. Poniższy kod do pętli nie zostanie skompilowany, co spowoduje komunikat o błędzie:

#włączać
za pomocą przestrzeni nazw Std;
int main ()

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

Cout<
Cout<powrót 0;

Zmienna iteracja, i, jest widoczna wewnątrz bloku na pętlę, ale nie poza blokiem pętli.

Zmienna zadeklarowana w zakresie globalnym to zmienna globalna. Można go zobaczyć w zakresie bloków. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
int glb = 5;
int main ()

Cout << glb << endl;
powrót 0;

Wyjście to 5.

Ponowne uznanie niedozwolone w globalnym zakresie

W poprzednim programie oświadczenie:

int glb = 5;

Jest to deklaracja z inicjalizacją (pierwsze przypisanie wartości) jednocześnie. W poniższym programie stwierdzenie „int glb;” ma zero przypisane do niego domyślnie. Linia po (glb = 5;) próbuje ponowne złożenie wartości, 5, w globalnym zakresie. Stwarza to błąd, a program nie kompiluje. Program to:

#włączać
za pomocą przestrzeni nazw Std;
int glb;
glb = 5;
int main ()

Cout << glb << endl;
powrót 0;

Jednak przeniesienie odbędzie się w zakresie lokalnym (blokowym), jak pokazano w następującym programie:

#włączać
za pomocą przestrzeni nazw Std;
int glb;
int main ()

if (1 == 1)
glb = 5;
Cout << glb << endl;

powrót 0;

Wyjście to 5.

Globalny wskaźnik

Gdy wskaźnik jest zadeklarowany w zakresie globalnym, można go zobaczyć w zagnieżdżonym zakresie. Wskaźnika ogłoszonego w zagnieżdżonym zakresie nie można zobaczyć poza zagnieżdżonym zakresem. Istnieją dwa sposoby deklarowania wskaźnika. Wskaźnik można zadeklarować za pomocą praktycznego zadania (adresu). Wskaźnik można zadeklarować bez praktycznego zadania. Jeśli wskaźnik zostanie ogłoszony bez praktycznego przypisania w zakresie globalnego, nie można go ponownie przypisać w globalnym zakresie. Jednak w tym przypadku można go ponownie przypisać w zagnieżdżonym zakresie.

Globalna tablica

Gdy tablica jest zadeklarowana w zakresie globalnym, można ją zobaczyć w zagnieżdżonym zakresie. Tablicy zadeklarowanej w zagnieżdżonym zakresie, nie można zobaczyć poza zagnieżdżonym zakresem. Istnieją dwa sposoby deklarowania tablicy. Tablicę można zadeklarować za pomocą praktycznego zadania (adresu). Tablicę można zadeklarować bez praktycznego zadania. Jeśli tablica jest zadeklarowana bez praktycznego przypisania w zakresie globalnego, nie można jej ponownie przypisać w zakresie globalnego. Można go jednak ponownie przypisać w zagnieżdżonym zakresie (element według elementu).

Szablon zakres parametrów

Normalny zakres nazwy parametru szablonu rozpoczyna się od punktu deklaracji do końca jej bloku, jak w poniższym przykładzie:

szablon struktura wieków

T John = 11;
U Peter = 12.3;
T Mary = 13;
U Joy = 14.6;
;

U i t są widoczne w bloku.

W przypadku prototypu funkcji szablonu zakres rozpoczyna 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);

Jednak jeśli chodzi o opis klasy (definicja), zakres może być również różnych porcji, jak w poniższym programie:

#włączać
za pomocą przestrzeni nazw Std;
szablon klasa thecla

publiczny:
T num;
statyczny u ch;
void Func (u cha, const char *str)

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

statyczna pustka zabawa (u ch)

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

;
int main ()

Thecla obj;
obj.num = 12;
obj.FUNC („$”, „500”);
powrót 0;

Ukrywa się nazwisko

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

#włączać
za pomocą przestrzeni nazw Std;
void fn ()

int var = 3;
if (1 == 1)

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

fn ();
powrót 0;

Wyjście to:

4
3

To dlatego, że var w zagnieżdżonym bloku HID var w bloku zewnętrznym.

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

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

Prototyp funkcji

Różne podmioty, nawet różnych typów, zwykle nie mogą być 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:

#włączać
za pomocą przestrzeni nazw Std;
void fn (int num);
void fn (int num);
void fn (int num)

Cout<
int main ()

fn (5);
powrót 0;

Program działa.

Przeciążone funkcje

Przeciążone funkcje są funkcjami o tej samej nazwie, ale z różnymi podpisami funkcji. Jako kolejny wyjątek, przeciążone funkcje o tej samej nazwie można zdefiniować w tym samym zakresie. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
void fn (int num)

Cout<
void fn (float no)

Cout<
int main ()

fn (5);
float flt = 8.7;
fn (flt);
powrót 0;

Wyjście to:

5
8.7

Przeciążone funkcje zostały zdefiniowane w zakresie globalnym.

Zakres przestrzeni nazw

Ponieważ dwie różne zmienne mogą mieć tę samą nazwę i w celu ich rozróżnienia, zmienne muszą być zadeklarowane w dwóch różnych przestrzeni nazw. Przestrzeń nazw to blok o nazwie, mając własne nazwane podmioty. Nazwa przestrzeni nazw to nazwa bloku. Dwie różne przestrzenie nazw mogą mieć byty o tych samych nazwiskach. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
Przestrzeń nazw na

char cH1;
char cH2 = „q”;

Przestrzeń nazw NB

char cH1;
char cH2 = „y”;

int main ()

Na :: CH1 = „P”;
Cout << NA::ch1 << endl;
Nb :: ch1 = 'x';
Cout << NB::ch1 << endl;
powrót 0;

Wyjście to:

P
X

Istnieją dwie przestrzenie nazw: NA i NB. Zdefiniowana przestrzeń dla Na jest jej blok. Zdefiniowana przestrzeń dla NB jest również jej blok. Zauważ, że podmioty w dwóch różnych blokach mają takie same nazwy. Aby zadeklarować przestrzeń nazw, zacznij od zastrzeżonego słowa, przestrzeni nazw; Następuje przestrzeń, a następnie blok ze swoimi podmiotami.

Aby uzyskać dostęp do jednostki poza blokiem przestrzeni nazw. Następnie następuje operator rozdzielczości zakresu, a następnie nazwa jednostki.

Zakres zmiennej, Na :: CH1, zaczyna się od punktu deklaracji CH1 w bloku Na. Kończy się na końcu bloku Na, a następnie pojawia się w dowolnej linii na zewnątrz (i poniżej) bloku, w którym używany jest „na ::”. Zakres zmiennej, NB :: CH1, zaczyna się od punktu deklaracji CH1 w bloku NB. Kończy się na końcu bloku NB i pojawia się w dowolnej linii na zewnątrz (i poniżej) bloku, w którym używany jest „nb ::”.

Zakres przestrzeni nazw odnosi się do jednostki zadeklarowanej w bloku przestrzeni nazw. Zakres encji przestrzeni nazw to blok przestrzeni nazw i dowolny wiersz poza blokiem, który używa nazwy przestrzeni nazw.

Zakres w różnych porcjach

Poprzednie zakresy klasy i przestrzeni nazwy zilustrowały, w jaki sposób może być zakres w różnych częściach tekstu programu. Kolejnym dobrym przykładem jest specyfikator przyjaciela.

Specyfikator przyjaciela

Jeśli klasa C jest ogłoszona jako przyjaciel klasy A, w definicji klasy A, wszystkie funkcje członka publicznego klasy C mogą uzyskać dostęp do prywatnych członków danych (i funkcji członków prywatnych) klasy A. Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
klasa A
prywatny: int d = 5;
Klasa przyjaciela C;
;
Klasa B
/*
public: int fb ()
A;
Zwrot a.D;

*/
;
Klasa C
public: int fc ()
A;
Zwrot a.D;

;
int main ()

A;
B B;
C C;
// int ret1 = b.pełne wyżywienie();
int ret2 = c.fc ();
Cout << ret2 << endl;
powrót 0;

Wyjście to 5. W definicji klasy A klasa C jest ogłoszona jako przyjaciel klasy A. Tak więc, FC () definicji klasy C, może zobaczyć D definicji klasy A. Program kompiluje. Jeśli symbole komentarzy zostaną usunięte, program nie zostanie skompilowany, ponieważ klasa B nie została ogłoszona przyjacielem klasy A.

Zakres zmiennej prywatnej B zaczyna się od punktu deklaracji i kończy na końcu bloku klasy A. Pojawia się również w funkcji FC () w klasie C, która jest przyjacielem klasy A. Dwie części dla zakresu to blok klasy A i blok funkcyjny FC ().

Wniosek

Zakres jest regionem deklaratywnym. Region deklaratywny jest największą częścią tekstu programu, w którym nazwa jednostki jest ważna. Można go podzielić na więcej niż jedną część z niektórymi schematami programowania, takimi jak zagnieżdżone bloki. Części, które nie mają punktu deklaracji, tworzą potencjalny zakres. Potencjalny zakres może mieć deklarację, ale nie.