Bereik in C++

Een entiteit in C++ heeft een naam, die kan worden gedeclareerd en/of gedefinieerd. Een verklaring is een definitie, maar een definitie is niet per se een verklaring. Een definitie wijst geheugen toe aan de benoemde entiteit, maar een declaratie kan al dan niet geheugen toewijzen aan de benoemde entiteit. Een declaratief gebied is het grootste deel van een programma waarin de naam van een entiteit (variabele) geldig is. Dat gebied wordt een bereik of een potentieel bereik genoemd. In dit artikel wordt scoping in C . uitgelegd++. Verder is basiskennis van C++ nodig om dit artikel te begrijpen.

Artikel Inhoud

Declaratieve regio en reikwijdte
Wereldwijd bereik
Bereik blokkeren
Functieomvang:
Opsommingsbereik
Klassebereik
Bereik van sjabloonparameter
Naam verbergen
Mogelijkheid om aangifte in hetzelfde bereik te herhalen
Naamruimtebereik
Bereik in verschillende porties
Conclusie

Declaratieve regio en reikwijdte

Een declaratief gebied is het grootste deel van een programmatekst waarin de naam van een entiteit geldig is. Het is de regio waarin de ongekwalificeerde naam kan worden gebruikt (gezien) om naar dezelfde entiteit te verwijzen. Beschouw het volgende korte programma:

#include
namespace std; gebruiken;
ongeldig fn()

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

cout<

int hoofd()

fn();
retourneer 0;

De functie fn() heeft twee blokken: een binnenste blok voor de if-conditie en een buitenste blok voor de functie body. De identifier, var, wordt geïntroduceerd en gezien in het buitenste blok. Het is ook te zien in het binnenste blok, met de cout-verklaring. De buitenste en binnenste blokken zijn beide het toepassingsgebied voor de naam, var.

De naam, var, kan echter nog steeds worden gebruikt om een andere entiteit te declareren, zoals een float in het binnenste blok. De volgende code illustreert dit:

#include
namespace std; gebruiken;
ongeldig fn()

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

zweven var = 7.5;
cout<

int hoofd()

fn();
retourneer 0;

De uitvoer is 7.5. In dit geval kan de naam, var, niet langer worden gebruikt in het binnenste blok om te verwijzen naar het gehele getal van waarde 3, dat werd geïntroduceerd (verklaard) in het buitenste blok. Dergelijke binnenblokken worden potentiële reikwijdte genoemd voor entiteiten die in het buitenblok zijn gedeclareerd.

Opmerking: een entiteit van hetzelfde type, zoals die van het buitenste blok, kan nog steeds worden gedeclareerd in het binnenste blok. In dit geval is wat echter geldig is in het binnenste blok de nieuwe verklaring en zijn betekenis, terwijl de oude verklaring en zijn betekenis buiten het binnenste blok geldig blijven in het buitenste blok.

Een verklaring met dezelfde naam in een binnenblok overschrijft normaal gesproken de verklaring met dezelfde naam buiten dat binnenblok. Binnenblokken kunnen andere binnenblokken nesten.

Wereldwijd bereik

Wanneer een programmeur net begint met het typen van een bestand, is dat het globale bereik. Het volgende korte programma illustreert dit:

#include
namespace std; gebruiken;
zweven var = 9.4;
int hoofd()

cout <cout <<::var<<'\n';
retourneer 0;

De uitvoer is:
9.4
9.4

In dit geval begint het declaratieve gebied of bereik voor var vanaf het declaratiepunt voor var en gaat het verder naar beneden tot het einde van het bestand (vertaaleenheid).

Het blok van de functie main() is een ander bereik; het is een geneste scope voor de globale scope. Om toegang te krijgen tot een entiteit van het globale bereik, vanuit een ander bereik, wordt de identifier rechtstreeks gebruikt of voorafgegaan door de operator voor bereikomzetting, :: .

Opmerking: De entiteit, main(), wordt ook gedeclareerd in het globale bereik.

Bereik blokkeren

De instructie if, while, do, for of switch kan elk een blok definiëren. Zo'n verklaring is een samengestelde verklaring. De naam van een variabele gedeclareerd in een blok heeft het bereik van een blok. Het bereik begint op het punt van declaratie en eindigt aan het einde van het blok its. Het volgende korte programma illustreert dit voor de variabele ident:

#include
namespace std; gebruiken;
int hoofd()

als (1==1)

/*sommige uitspraken*/
int ident = 5;
cout</*sommige uitspraken*/

retourneer 0;

Een variabele, zoals ident, gedeclareerd bij block scope is een lokale variabele.

Een variabele gedeclareerd buiten het bereik van het blok en daarboven is te zien in de kop van het blok (e.g., voorwaarde voor if-blok) en ook binnen het blok. Het volgende korte programma illustreert dit voor de variabele identif:

#include
namespace std; gebruiken;
int hoofd()

int identif = 8;
als (identif == 8)

cout<
retourneer 0;

De uitvoer is 8. Er zijn hier twee blokbereiken: het blok voor de functie main() en de geneste if-compound-instructie. Het geneste blok is het potentiële bereik van het functieblok main().

Een declaratie die is geïntroduceerd in een blokbereik kan niet buiten het blok worden gezien. Het volgende korte programma, dat niet compileert, illustreert dit met de variabele variab:

#include
namespace std; gebruiken;
int hoofd()

als (1 == 1)

int variab = 15;

cout<retourneer 0;

De compiler produceert een foutmelding voor variab.

Een geïntroduceerde entiteit, gedeclareerd in de kop van een samengestelde functie, kan niet worden gezien buiten (onder) de samengestelde instructie. De volgende for-loop-code kan niet worden gecompileerd, wat resulteert in een foutmelding:

#include
namespace std; gebruiken;
int hoofd()

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

cout<
cout<retourneer 0;

De iteratievariabele, i, wordt binnen het for-loop-blok gezien, maar niet buiten het for-loop-blok.

Functieomvang:

Een functieparameter is te zien in het functieblok. Een entiteit gedeclareerd in een functieblok wordt gezien vanaf het punt van declaratie tot het einde van het functieblok. Het volgende korte programma illustreert dit:

#include
#include
namespace std; gebruiken;
string fn(string str)

char stri[] = "bananen";
/*andere verklaringen*/
tekenreeks totaalStr = str + stri;
retourneer totaalStr;

int hoofd()

string totStr = fn("eten ");
cout<retourneer 0;

De uitvoer is:
bananen eten

Opmerking: een entiteit die buiten de functie (hierboven) is gedeclareerd, is te zien in de lijst met functieparameters en ook in het functieblok.

Etiket

Het bereik van een label is de functie waarin het verschijnt. De volgende code illustreert dit:

#include
namespace std; gebruiken;
ongeldig fn()

ga naar labl;
/*andere verklaringen*/
labl: int inte = 2;
cout<
int hoofd()

fn();
retourneer 0;

De uitvoer is 2.

Opsommingsbereik

Telling zonder scope
Overweeg het volgende if-blok:

als (1==1)

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

De uitvoer is 0 1 3.

De eerste regel in het blok is een opsomming, a, b en c zijn de tellers. De reikwijdte van een enumerator begint vanaf het punt van declaratie tot het einde van het omsluitende blok van de opsomming.

De volgende verklaring wordt niet gecompileerd omdat het declaratiepunt van c na dat van a ligt:

enum a=c+2, b, c;

Het volgende codesegment wordt niet gecompileerd omdat de enumerators worden geopend na het omsluitende blok van de opsomming:

als (1==1)

enum a, b, c=b+2;

cout<De bovenstaande opsomming wordt beschreven als een opsomming zonder scope, en de tellers worden beschreven als niet-scoped opsommingen. Dit komt omdat het alleen begint met het gereserveerde woord, enum. Opsommingen die beginnen met enum class of enum struct worden beschreven als scoped opsommingen. Hun enumerators worden beschreven als scoped enumerators.

Scoped opsomming
De volgende stelling is oké:

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

Dit is een voorbeeld van een scoped opsomming. De naam van de klas is nam. Hier begint de reikwijdte van de enumerator vanaf het declaratiepunt tot het einde van de opsommingsdefinitie, en niet het einde van het omsluitende blok voor de opsomming. De volgende code wordt niet gecompileerd:

als (1==1)

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

Klassebereik

Bij normale scoping begint het declaratieve gebied vanaf een punt, gaat dan verder en stopt op een ander punt. Het bereik bestaat in één aaneengesloten regio. Met de klasse kan het bereik van een entiteit zich in verschillende regio's bevinden die niet zijn samengevoegd. De regels voor geneste blokken zijn nog steeds van toepassing. Het volgende programma illustreert dit:

#include
namespace std; gebruiken;
//Basisklasse
klasse Cla

privaat:
int memP = 5;
beschermd:
int memPro = 9;
openbaar:
ongeldig fn()

cout<
;
//Afgeleide klasse
klasse DerCla: openbare Cla

openbaar:
int derMem = memPro;
;
int hoofd()

Kla obj;
obj.fn();
DerCla derObj;
cout<retourneer 0;

De uitvoer is:
5
9

In de klasse Cla, de variabele memP, wordt gezien op het punt van declaratie. Daarna wordt het korte gedeelte van "beschermd" overgeslagen en vervolgens opnieuw weergegeven in het functieblok voor klassenleden. De afgeleide klasse wordt overgeslagen en vervolgens opnieuw gezien in het functiebereik (blok) main().

In de klasse Cla, de variabele memPro, wordt gezien op het punt van declaratie. Het gedeelte van de openbare functie fn() wordt overgeslagen en wordt vervolgens weergegeven in het afgeleide klassebeschrijvingsblok. Het wordt opnieuw weergegeven in de functie main().

Scope Resolutie Operator
De scope resolutie-operator in C++ is :: . Het wordt gebruikt om toegang te krijgen tot een statisch lid van de klas. Het volgende programma illustreert dit:

#include
namespace std; gebruiken;
klasse Cla

openbaar:
statisch int const mem = 5;
openbaar:
statische leegte fn()

cout<
;
int hoofd()

cout<Cla::fn();
retourneer 0;

De uitvoer is:
5
5

De statische leden zijn te zien in het functieblok main(), toegankelijk met behulp van de scope-resolutie-operator.

Bereik van sjabloonparameter

Het normale bereik van een sjabloonparameternaam begint vanaf het declaratiepunt tot het einde van het blok, zoals in de volgende code:

sjabloon struct Ages

T Johannes = 11;
U Peter = 12.3;
T Maria = 13;
U Vreugde = 14.6;
;

U en T worden binnen het blok gezien.

Voor een prototype van een sjabloonfunctie begint het bereik vanaf het declaratiepunt tot het einde van de functieparameterlijst, zoals in de volgende instructie:

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

Als het echter gaat om de klassebeschrijving (definitie), kan het bereik ook uit verschillende delen bestaan, zoals in de volgende code:

#include
namespace std; gebruiken;
sjabloon klasse TheCla

openbaar:
T aantal;
statisch Uch;
void func (U cha, const char *str)

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

statische leegte plezier (U ch)

als (ch == 'a')
cout << "Official static member function" << '\n';

;
int hoofd()

De Cla obj;
obj.aantal = 12;
obj.func('$', "500");
retourneer 0;

Naam verbergen

Een voorbeeld van naam verbergen doet zich voor wanneer de naam van hetzelfde objecttype opnieuw wordt gedeclareerd in een genest blok. Het volgende programma illustreert dit:

#include
namespace std; gebruiken;
ongeldig fn()

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

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

fn();
retourneer 0;

De uitvoer is:
4
3

Het is omdat var in het geneste blok var in het buitenste blok verborg.

Mogelijkheid om aangifte in hetzelfde bereik te herhalen

Het punt van de verklaring is waar de naam (voor de eerste keer) in zijn bereik wordt geïntroduceerd.

Functie Prototype:
Verschillende entiteiten, zelfs van verschillende typen, kunnen normaal gesproken niet binnen hetzelfde toepassingsgebied worden gedeclareerd. Een functie-prototype kan echter meer dan eens in hetzelfde bereik worden gedeclareerd. Het volgende programma met twee functie-prototypes en bijbehorende functiedefinitie illustreert dit:

#include
namespace std; gebruiken;
void fn(int num);
void fn(int num);
ongeldig fn(int num)

cout<
int hoofd()

fn(5);
retourneer 0;

Het programma werkt.

Overbelaste functies
Overbelaste functies zijn functies met dezelfde naam maar verschillende functiehandtekeningen. Als een andere uitzondering kunnen overbelaste functies met dezelfde naam in hetzelfde bereik worden gedefinieerd. Het volgende programma illustreert dit:

#include
namespace std; gebruiken;
ongeldig fn(int num)

cout<
void fn (float nee)

cout<
int hoofd()

fn(5);
vlotter flt = 8.7;
fn(flt);
retourneer 0;

De uitvoer is:
5
8.7

De overbelaste functies zijn gedefinieerd in de globale scope.

Naamruimtebereik

Namespace Scope verdient een eigen artikel. Het genoemde artikel is geschreven voor deze website, linuxhint.com. Typ gewoon de zoekwoorden "Namespace Scope" in het zoekvak van deze site (pagina) en klik op OK, en u krijgt het artikel.

Bereik in verschillende delen Port

De klasse is niet het enige schema waarbij het bereik in verschillende delen kan zijn. Friend-specificatie, bepaald gebruik van de uitgewerkte-type-specificatie en gebruiksrichtlijnen zijn andere schema's waarbij het toepassingsgebied zich op verschillende plaatsen bevindt - voor details, zie later.

Conclusie

Een scope is een declaratief gebied. Een declaratief gebied is het grootste deel van een programmatekst waarin de naam van een entiteit geldig is. Het kan in meer dan één gedeelte worden verdeeld in overeenstemming met bepaalde programmeerschema's, zoals geneste blokken. De gedeelten die het declaratiepunt niet hebben, vormen het potentiële bereik. Het potentiële bereik kan al dan niet de verklaring hebben.