Ambito in C++

Un'entità in C++ ha un nome, che può essere dichiarato e/o definito. Una dichiarazione è una definizione, ma una definizione non è necessariamente una dichiarazione. Una definizione alloca memoria per l'entità nominata, ma una dichiarazione può o non può allocare memoria per l'entità nominata. Una regione dichiarativa è la parte più grande di un programma in cui è valido il nome di un'entità (variabile). Quella regione è chiamata ambito o potenziale ambito. Questo articolo spiega l'ambito in C++. Inoltre, sono necessarie conoscenze di base in C++ per comprendere questo articolo.

Contenuto dell'articolo

Regione dichiarativa e ambito
Ambito globale
Ambito di blocco
Ambito della funzione
Ambito di enumerazione
Ambito di classe
Ambito del parametro del modello
Nascondere il nome
Possibilità di ripetere la dichiarazione nello stesso ambito
Ambito spazio dei nomi Name
Ambito in diverse porzioni
Conclusione

Regione dichiarativa e ambito

Una regione dichiarativa è la parte più grande di un testo di programma in cui è valido il nome di un'entità. È la regione in cui il nome non qualificato può essere utilizzato (visto) per riferirsi alla stessa entità. Considera il seguente breve programma:

#includere
usando lo spazio dei nomi std;
vuoto fn()

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

cout<

intero principale()

fn();
restituisce 0;

La funzione fn() ha due blocchi: un blocco interno per la condizione if e un blocco esterno per il corpo della funzione. L'identificatore, var, viene introdotto e visto nel blocco esterno. Si vede anche nel blocco interno, con l'istruzione cout. I blocchi esterno e interno sono entrambi l'ambito per il nome, var.

Tuttavia, il nome, var, può ancora essere usato per dichiarare un'entità diversa come un float nel blocco interno. Il codice seguente lo illustra:

#includere
usando lo spazio dei nomi std;
vuoto fn()

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

variabile variabile = 7.5;
cout<

intero principale()

fn();
restituisce 0;

L'uscita è 7.5. In questo caso il nome, var, non può più essere utilizzato nel blocco interno per riferirsi all'intero di valore 3, che è stato introdotto (dichiarato) nel blocco esterno. Tali blocchi interni sono indicati come ambito potenziale per le entità dichiarate nel blocco esterno.

Nota: un'entità dello stesso tipo, come quella del blocco esterno, può ancora essere dichiarata nel blocco interno. Tuttavia, in questo caso, ciò che è valido nel blocco interno è la nuova dichiarazione e il suo significato, mentre la vecchia dichiarazione e il suo significato al di fuori del blocco interno rimangono validi nel blocco esterno.

Una dichiarazione con lo stesso nome in un blocco interno normalmente sovrascrive la dichiarazione con lo stesso nome al di fuori di quel blocco interno. I blocchi interni possono annidare altri blocchi interni.

Ambito globale

Quando un programmatore inizia a digitare un file, questo è l'ambito globale. Il seguente breve programma lo illustra:

#includere
usando lo spazio dei nomi std;
variabile variabile = 9.4;
intero principale()

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

L'uscita è:
9.4
9.4

In questo caso, la regione dichiarativa o l'ambito per var inizia dal punto di dichiarazione per var, continua verso il basso fino alla fine del file (unità di traduzione).

Il blocco della funzione main() è un ambito diverso; è un ambito annidato per l'ambito globale. Per accedere a un'entità dell'ambito globale, da un ambito diverso, l'identificatore viene utilizzato direttamente o preceduto dall'operatore di risoluzione dell'ambito, :: .

Nota: anche l'entità main() è dichiarata nell'ambito globale.

Ambito di blocco

L'istruzione if, while, do, for o switch può definire un blocco. Tale affermazione è un'affermazione composta. Il nome di una variabile dichiarata in un blocco ha l'ambito di un blocco. Il suo ambito inizia al punto di dichiarazione e termina alla fine del suo blocco. Il seguente breve programma illustra questo per la variabile, ident:

#includere
usando lo spazio dei nomi std;
intero principale()

se (1==1)

/*alcune dichiarazioni*/
int ident = 5;
cout</*alcune dichiarazioni*/

restituisce 0;

Una variabile, come ident, dichiarata nell'ambito del blocco è una variabile locale.

Una variabile dichiarata al di fuori dell'ambito del blocco e al di sopra di essa può essere vista nell'intestazione del blocco (e.g., condizione per if-block) e anche all'interno del blocco. Il seguente breve programma illustra questo per la variabile, identif:

#includere
usando lo spazio dei nomi std;
intero principale()

int identificativo = 8;
se (identificativo == 8)

cout<
restituisce 0;

L'uscita è 8. Ci sono due ambiti di blocco qui: il blocco per la funzione main() e l'istruzione if-compound annidata. Il blocco annidato è l'ambito potenziale del blocco funzione main().

Una dichiarazione introdotta in un ambito di blocco non può essere vista al di fuori del blocco. Il seguente breve programma, che non compila, lo illustra con la variabile variabile:

#includere
usando lo spazio dei nomi std;
intero principale()

se (1 == 1)

int variabile = 15;

cout<restituisce 0;

Il compilatore produce un messaggio di errore per variab.

Un'entità introdotta, dichiarata nell'intestazione di una funzione composta, non può essere vista fuori (sotto) l'istruzione composta. Il seguente codice del ciclo for non verrà compilato, generando un messaggio di errore:

#includere
usando lo spazio dei nomi std;
intero principale()

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

cout<
cout<restituisce 0;

La variabile di iterazione, i, è vista all'interno del blocco del ciclo for ma non all'esterno del blocco del ciclo for.

Ambito della funzione

Un parametro funzione è visto nel blocco funzione. Un'entità dichiarata in un blocco funzione è vista dal punto di dichiarazione alla fine del blocco funzione function. Il seguente breve programma lo illustra:

#includere
#includere
usando lo spazio dei nomi std;
stringa fn(stringa str)

char stri[] = "banane";
/*altre dichiarazioni*/
stringa totalStr = str + stri;
restituire totalStr;

intero principale()

string totStr = fn("mangiare");
cout<restituisce 0;

L'uscita è:
mangiare banane

Nota: un'entità dichiarata al di fuori della funzione (sopra) può essere vista nell'elenco dei parametri della funzione e anche nel blocco funzione.

Etichetta

L'ambito di un'etichetta è la funzione in cui appare. Il codice seguente lo illustra:

#includere
usando lo spazio dei nomi std;
vuoto fn()

vai a labl;
/*altre dichiarazioni*/
labl: int inte = 2;
cout<
intero principale()

fn();
restituisce 0;

L'uscita è 2.

Ambito di enumerazione

Enumerazione senza ambito
Considera il seguente blocco se:

se (1==1)

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

L'uscita è 0 1 3.

La prima riga nel blocco è un'enumerazione, a, b e c sono i suoi enumeratori. L'ambito di un enumeratore inizia dal punto di dichiarazione fino alla fine del blocco che racchiude l'enumerazione.

La seguente istruzione non verrà compilata perché il punto di dichiarazione di c è successivo a quello di a:

enum a=c+2, b, c;

Il seguente segmento di codice non verrà compilato perché si accede agli enumeratori dopo il blocco di inclusione dell'enumerazione:

se (1==1)

enum a, b, c=b+2;

cout<L'enumerazione di cui sopra è descritta come un'enumerazione senza ambito e i suoi enumeratori sono descritti come enumeratori senza ambito. Questo perché inizia solo con la parola riservata, enum. Le enumerazioni che iniziano con enum class o enum struct sono descritte come enumerazioni con scope. I loro enumeratori sono descritti come enumeratori scoped.

Enumerazione con ambito
La seguente affermazione è OK:

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

Questo è un esempio di enumerazione con scoped. Il nome della classe è nam. Qui, l'ambito dell'enumeratore inizia dal punto di dichiarazione fino alla fine della definizione dell'enumerazione e non alla fine del blocco di inclusione per l'enumerazione. Il seguente codice non verrà compilato:

se (1==1)

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

Ambito di classe

Con lo scoping normale, la regione dichiarativa inizia da un punto, quindi continua e si ferma in un punto diverso. L'ambito esiste in una regione continua. Con la classe, l'ambito di un'entità può trovarsi in regioni diverse che non sono unite insieme. Le regole per i blocchi nidificati si applicano ancora. Il seguente programma lo illustra:

#includere
usando lo spazio dei nomi std;
//Classe base
classe Cla

privato:
int memP = 5;
protetto:
int memPro = 9;
pubblico:
vuoto fn()

cout<
;
//Classe derivata
classe DerCla: Cla pubblico

pubblico:
int derMem = memPro;
;
intero principale()

Cla obj;
obj.fn();
DerCla derObj;
cout<restituisce 0;

L'uscita è:
5
9

Nella classe Cla, la variabile memP, è vista al punto di dichiarazione. Successivamente, la breve porzione di "protetto" viene saltata, quindi visualizzata di nuovo nel blocco funzione membro della classe. La classe derivata viene saltata, quindi vista di nuovo nell'ambito della funzione main() (blocco).

Nella classe Cla, la variabile memPro, è vista al punto di dichiarazione. La parte della funzione pubblica fn() viene saltata, quindi vista nel blocco di descrizione della classe derivata. Si vede di nuovo nella funzione main().

Operatore di risoluzione dell'ambito
L'operatore di risoluzione dell'ambito in C++ è :: . Viene utilizzato per accedere a un membro statico della classe. Il seguente programma lo illustra:

#includere
usando lo spazio dei nomi std;
classe Cla

pubblico:
statico int const mem = 5;
pubblico:
vuoto statico fn()

cout<
;
intero principale()

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

L'uscita è:
5
5

I membri statici sono visualizzati nel blocco funzione main(), a cui si accede utilizzando l'operatore di risoluzione dell'ambito.

Ambito del parametro del modello

L'ambito normale di un nome di parametro modello inizia dal punto di dichiarazione alla fine del suo blocco, come nel codice seguente:

modello struttura Età

T Giovanni = 11;
U Pietro = 12.3;
T Maria = 13;
U Gioia = 14.6;
;

U e T sono visti all'interno del blocco.

Per un prototipo di funzione modello, l'ambito inizia dal punto di dichiarazione fino alla fine dell'elenco dei parametri della funzione, come nell'istruzione seguente:

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

Tuttavia, quando si tratta della descrizione della classe (definizione), l'ambito può anche essere di parti diverse come nel codice seguente:

#includere
usando lo spazio dei nomi std;
modello classe TheCla

pubblico:
T numero;
statico U ch;
void func (U cha, const char *str)

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

divertimento vuoto statico (U ch)

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

;
intero principale()

TheCla oggetto;
obj.numero = 12;
obj.func('$', "500");
restituisce 0;

Nascondere il nome

Un esempio di nascondimento del nome si verifica quando il nome dello stesso tipo di oggetto viene dichiarato nuovamente in un blocco annidato. Il seguente programma lo illustra:

#includere
usando lo spazio dei nomi std;
vuoto fn()

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

int var = 4;
cout<
cout<
intero principale()

fn();
restituisce 0;

L'uscita è:
4
3

È perché var nel blocco annidato ha nascosto var nel blocco esterno.

Possibilità di ripetere la dichiarazione nello stesso ambito

Il punto della dichiarazione è dove il nome viene introdotto (per la prima volta) nel suo ambito.

Prototipo di funzione
Entità diverse, anche di tipo diverso, non possono normalmente essere dichiarate nello stesso ambito. Tuttavia, un prototipo di funzione può essere dichiarato più di una volta nello stesso ambito. Il seguente programma con due prototipi di funzione e la corrispondente definizione di funzione lo illustra:

#includere
usando lo spazio dei nomi std;
void fn(int num);
void fn(int num);
void fn(int num)

cout<
intero principale()

fn(5);
restituisce 0;

Il programma funziona.

Funzioni sovraccaricate
Le funzioni sovraccaricate sono funzioni con lo stesso nome ma firme di funzione diverse. Come altra eccezione, le funzioni sovraccaricate con lo stesso nome possono essere definite nello stesso ambito. Il seguente programma lo illustra:

#includere
usando lo spazio dei nomi std;
void fn(int num)

cout<
void fn(n. float)

cout<
intero principale()

fn(5);
float flt = 8.7;
fn(flat);
restituisce 0;

L'uscita è:
5
8.7

Le funzioni sovraccaricate sono state definite nell'ambito globale.

Ambito spazio dei nomi Name

Namespace Scope merita il suo articolo. Il suddetto articolo è stato scritto per questo sito Web, linuxhint.come. Basta digitare le parole di ricerca "Ambito dello spazio dei nomi" nella casella di ricerca di questo sito (pagina) e fare clic su OK e otterrai l'articolo.

Ambito in diverse porzioni

La classe non è l'unico schema in cui l'ambito può essere in porzioni diverse. L'identificatore amico, alcuni usi dell'identificatore di tipo elaborato e le direttive using sono altri schemi in cui l'ambito si trova in luoghi diversi - per i dettagli, vedere più avanti.

Conclusione

Un ambito è una regione dichiarativa. Una regione dichiarativa è la parte più grande di un testo di programma in cui è valido il nome di un'entità. Può essere suddiviso in più porzioni secondo determinati schemi di programmazione, come i blocchi annidati. Le parti che non hanno il punto di dichiarazione costituiscono l'ambito potenziale. Il potenziale ambito può o meno avere la dichiarazione.