Portée en C ++

Une entité en C ++ a un nom, qui peut être déclaré et / ou défini. Une déclaration est une définition, mais une définition n'est pas nécessairement une déclaration. Une définition alloue la mémoire à l'entité nommée, mais une déclaration peut ou non allouer de la mémoire à l'entité nommée. Une région déclarative est la plus grande partie d'un programme dans lequel le nom d'une entité (variable) est valide. Cette région est appelée portée ou portée potentielle. Cet article explique la portée en C++. De plus, une connaissance de base de C ++ est nécessaire pour comprendre cet article.

Contenu de l'article

• Région et portée déclarative
• Portée mondiale
• Variables globales et portée globale
• Portée
• Portée de la fonction
• Portée de la classe
• Portée de l'énumération
• Variable globale
• Portée du paramètre de modèle
• Nom cachette
• Possibilité de répéter la déclaration dans la même portée
• Portée de l'espace de noms
• Portée en différentes parties
• Conclusion

Région et portée déclarative

Une région déclarative est la plus grande partie d'un texte de programme dans lequel le nom d'une entité est valide. La région où le nom non qualifié peut être utilisé (vu) pour se référer à la même entité. Considérez le programme court suivant:

#inclure
Utilisation de Namespace Std;
void fn ()

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

couter<

int main()

fn ();
retour 0;

La fonction fn () a deux blocs: un bloc intérieur pour la condition IF et un bloc extérieur pour le corps de la fonction. L'identifiant, var, est introduit et vu dans le bloc extérieur. Il est également vu dans le bloc intérieur, avec la déclaration de cout. Les blocs extérieurs et intérieurs sont la portée du nom, var.

Cependant, le nom, var, peut toujours être utilisé pour déclarer une entité différente, comme un flotteur, dans le bloc intérieur. Le code suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
void fn ()

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

float var = 7.5;
couter<

int main()

fn ();
retour 0;

La sortie est

7.5

Dans ce cas, le nom, var, ne peut plus être utilisé dans le bloc intérieur pour se référer à l'entier de la valeur 3, qui a été introduit (déclaré) dans le bloc extérieur. Ces blocs intérieurs sont appelés portée potentielle pour les entités déclarées dans le bloc extérieur.

Remarque: Une entité du même type, comme le bloc extérieur, peut toujours être déclarée dans le bloc intérieur. Cependant, dans ce cas, la nouvelle déclaration et sa signification sont valables dans le bloc intérieur, tandis que l'ancienne déclaration et signification en dehors du bloc intérieur ne restent valables que dans le bloc extérieur.

Une déclaration du même nom dans un bloc intérieur remplace normalement la déclaration du même nom en dehors de ce bloc intérieur. Les blocs intérieurs peuvent nicher d'autres blocs intérieurs.

Portée mondiale

Lorsqu'un programmeur commence à taper un fichier, c'est la portée globale. Le programme court suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
float var = 9.4;
int main()

couter <couter <<::var<<'\n';
retour 0;

La sortie est:

9.4
9.4

Dans ce cas, la région déclarative ou la portée de la VAR commence à partir du point de déclaration de VAR, et se poursuit vers le bas jusqu'à la fin du fichier (unité de traduction).

Le bloc de la fonction principale () est une portée différente; C'est une portée imbriquée pour la portée mondiale. Pour accéder à une entité de la portée globale à partir d'une portée différente, l'identifiant est utilisé directement ou précédé de l'opérateur de résolution de portée, :: .

Remarque: l'entité, main (), est également déclarée dans la portée mondiale.

Portée

Les instructions if, tandis que, pour ou commutation peuvent chacune définir un bloc. Une telle déclaration est une déclaration composée. Le nom d'une variable déclarée dans un bloc a une portée d'un bloc. Sa portée commence à son point de déclaration et se termine à la fin de son bloc. Le programme court suivant illustre cela pour la variable, Identity:

#inclure
Utilisation de Namespace Std;
int main()

si (1 == 1)

/ * quelques instructions * /
int identif = 5;
couter</ * quelques instructions * /

retour 0;

Une variable, comme identi.

Une variable déclarée en dehors de la portée du bloc et au-dessus, elle peut être vue dans l'en-tête du bloc (e.g., condition pour le bloc if) et dans le bloc. Le programme court suivant illustre cela pour la variable, identif:

#inclure
Utilisation de Namespace Std;
int main()

int identif = 8;
if (identif == 8)

couter<
retour 0;

La sortie est,

8

Il y a deux lunettes de bloc: le bloc pour la fonction principale () et l'instruction IF-compound imbriquée. Le bloc imbriqué est la portée potentielle du bloc fonction principal ().

Une déclaration introduite dans une lunette de bloc ne peut pas être vue en dehors du bloc. Le programme court suivant, qui ne compile pas, illustre cela avec la variable, variab:

#inclure
Utilisation de Namespace Std;
int main()

si (1 == 1)

int variab = 15;

couter<retour 0;

Le compilateur produit un message d'erreur pour Variab.

Une entité introduite, déclarée dans l'en-tête d'une fonction composée, ne peut pas être vue en dehors (ci-dessous) l'instruction composée. Le code pour boucle suivante ne se compile pas, ce qui entraînera un message d'erreur:

#inclure
Utilisation de Namespace Std;
int main()

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

couter<
couter<retour 0;

La variable d'itération, I, est vue à l'intérieur du bloc de boucle pour la boucle mais pas à l'extérieur du bloc de boucle pour.

Portée de la fonction

Un paramètre de fonction est vu dans le bloc fonction. Une entité déclarée dans un bloc fonctionnel est visible du point de déclaration à la fin du bloc fonction. Le programme court suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
String fn (String Str)

char stri [] = "bananes";
/ * Autres instructions * /
String totalstr = str + stri;
retour totalstr;

int main()

String totStr = fn ("manger");
couter<retour 0;

La sortie est:

manger des bananes

Remarque: Une entité déclarée en dehors de la fonction (au-dessus de lui) peut être vue dans la liste des paramètres de fonction et le bloc fonction.

Étiqueter

La portée d'une étiquette est la fonction dans laquelle il apparaît. Le code suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
void fn ()

goto labl;
/ * Autres instructions * /
labl: int Inte = 2;
couter<
int main()

fn ();
retour 0;

La sortie est

2

Portée de la classe

Avec la portée normale, la région déclarative commence à partir d'un point du programme, continue et s'arrête à un moment différent. La portée existe dans une région continue. Avec la classe, la portée d'une entité peut être dans différentes régions qui ne sont pas réunies. Les règles de blocs imbriquées s'appliquent toujours. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
// classe de base
classe CLA

privé:
Int MEMP = 5;
protégé:
int mempro = 9;
public:
void fn ()

couter<
;
//Classe dérivée
classe Dercla: CLA publique

public:
int dermm = MEMPRO;
;
int main()

CLA OBJ;
obj.fn ();
Dercla dérobj;
couter<retour 0;

La sortie est:

5
9

Dans la classe CLA, le MEMP variable est vu au point de déclaration. Après cela, la partie courte de «protégé» est ignorée et revêtue dans le bloc de fonction des membres de la classe. La classe dérivée est ignorée et revue à la portée de la fonction principale () (bloc).

Dans la classe CLA, la variable, Mempro, est vue au point de déclaration. La partie de la fonction publique fn () est ignorée, puis vue dans le bloc de description de classe dérivée. Il est revu dans la fonction principale ().

Opérateur de résolution de portée

L'opérateur de résolution de portée en C ++ est :: . Il est utilisé pour accéder à un membre statique de la classe. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
classe CLA

public:
statique int const mem = 5;
public:
vide statique fn ()

couter<
;
int main()

couter<CLA :: fn ();
retour 0;

La sortie est:

5
5

Les membres statiques sont observés dans le bloc fonction principal (), accessible à l'aide de l'opérateur de résolution de portée.

Portée de l'énumération

Énumération non -copée

Considérez le bloc if suivant:

si (1 == 1)

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

La sortie est:

0 1 3

La première ligne du bloc est une énumération; A, B et C sont ses énumérateurs. La portée d'un énumérateur commence du point de sa déclaration, à la fin du bloc d'encluse de l'énumération.

La déclaration suivante ne se compilera pas car le point de déclaration de C est après celui de a:

enum a = c + 2, b, c;

Le segment de code suivant ne se compilera pas car les énumérateurs sont accessibles après le bloc d'encluse de l'énumération:

si (1 == 1)

enum a, b, c = b + 2;

couter<

L'énumération précédente est décrite comme une énumération noncopée, et ses énumérateurs sont définis comme des énumérateurs noncopés. C'est parce qu'il commence uniquement avec le mot réservé, enum. Les énumérations qui commencent par la classe d'énumération ou l'énumération sont décrites comme des énumérations dans le cadre. Leurs énumérateurs sont définis comme des énumérateurs de portée.

Énumération dans les parasites

L'énoncé suivant est ok:

ENUM CLASSE NAM A, B, C = B + 2;

Ceci est un exemple d'une énumération dans les plans. Le nom de la classe est nam. Ici, la portée de l'énumérateur commence du point de déclaration à la fin de la définition de l'énumération et non à la fin du bloc d'encluture pour l'énumération. Le code suivant ne compilera pas:

si (1 == 1)

ENUM CLASSE NAM A, B, C = B + 2;
couter<

Utilisation simple de l'énumération portée

Le code suivant montre un moyen simple d'utiliser l'énumération dans l'étendue:

si (1 == 1)

enum nam a, b, c = b + 2;
couter << c << endl; //simple usage

La sortie est 3, car B est 1 ('a' est 0).

Variable globale

Une variable globale est une variable déclarée dans la portée globale. Lorsqu'un programmeur commence à taper un fichier, c'est la portée globale. Considérez le programme suivant:

#inclure
Utilisation de Namespace Std;
char va = 'a';
int main()

couter <couter <<::va<<'\n';
retour 0;

La sortie est:

UN
UN

Dans ce programme, la partie ou la portée de VA commence à partir du point de déclaration de l'AV et se poursuit vers le bas jusqu'à la fin de l'unité de traduction (fichier).

Le corps de la fonction principale est une portée différente à part entière; La portée globale niche la portée de la fonction principale ().

La variable VA est une variable de portée globale ou simplement une variable globale car elle peut être vue partout dans le fichier, à partir d'où il a été déclaré. Il peut être vu dans la portée de la fonction principale ().

Pour accéder à une variable globale (variable de la portée globale) à partir d'une portée différente, le nom de variable est utilisé directement ou précédé de l'opérateur de résolution de portée, :: comme indiqué dans le programme ci-dessus.

L'instruction if, while, faire, pour ou commutation peut chacune définir un bloc. Une telle déclaration est une déclaration composée. Le nom d'une variable déclarée dans un bloc a une portée d'un bloc. Sa portée commence à son point de déclaration et se termine à la fin de son bloc. Le programme court suivant illustre cela pour la variable, Identity:

#inclure
Utilisation de Namespace Std;
int main()

si (1 == 1)

/ * quelques instructions * /
int identif = 5;
couter</ * quelques instructions * /

retour 0;

Une variable, comme identi.

Une variable déclarée en dehors de la portée du bloc et au-dessus, elle peut être vue dans l'en-tête du bloc (e.g., condition pour le bloc if) et dans le bloc. Le programme court suivant illustre cela pour la variable, identif:

#inclure
Utilisation de Namespace Std;
int main()

int identif = 8;
if (identif == 8)

couter<
retour 0;

La sortie est,

8

Il y a deux portées de blocs ici: le bloc pour la fonction principale () et la déclaration if-compound imbriquée. Le bloc imbriqué est la portée potentielle du bloc fonction principal ().

Une déclaration introduite dans une lunette de bloc ne peut pas être vue en dehors du bloc. Le programme court suivant, qui ne compile pas, illustre cela avec la variable, variab:

#inclure
Utilisation de Namespace Std;
int main()

si (1 == 1)

int variab = 15;

couter<retour 0;

Le compilateur produit un message d'erreur pour Variab.

Une entité introduite, déclarée dans l'en-tête d'une fonction composée, ne peut pas être vue en dehors (ci-dessous) l'instruction composée. Le code pour boucle suivante ne se compile pas, ce qui entraînera un message d'erreur:

#inclure
Utilisation de Namespace Std;
int main()

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

couter<
couter<retour 0;

La variable d'itération, I, est vue à l'intérieur du bloc de boucle pour la boucle mais pas à l'extérieur du bloc de boucle pour.

Une variable déclarée dans la portée globale est une variable globale. Il peut être vu à l'intérieur d'une portée de bloc. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
int glb = 5;
int main()

couter << glb << endl;
retour 0;

La sortie est 5.

Réaffectation non autorisée dans la portée mondiale

Dans le programme précédent, la déclaration:

int glb = 5;

Il s'agit d'une déclaration avec initialisation (première affectation de valeur) simultanément). Dans le programme suivant, la déclaration «int GlB»; a zéro qui lui est affecté par défaut. La ligne après (glb = 5;) essaie la réaffectation de la valeur, 5, dans la portée globale. Cela crée une erreur, et le programme ne compile pas. Le programme est:

#inclure
Utilisation de Namespace Std;
int glb;
glb = 5;
int main()

couter << glb << endl;
retour 0;

Cependant, la réaffectation aura lieu dans une portée locale (bloc), comme indiqué dans le programme suivant:

#inclure
Utilisation de Namespace Std;
int glb;
int main()

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

retour 0;

La sortie est 5.

Pointeur global

Lorsqu'un pointeur est déclaré dans la portée mondiale, il peut être vu dans une portée imbriquée. Un pointeur déclaré dans une lunette imbriquée ne peut pas être vu en dehors de la portée imbriquée. Il y a deux façons de déclarer un pointeur. Un pointeur peut être déclaré avec une affectation pratique (d'une adresse). Un pointeur peut être déclaré sans une affectation pratique. Si le pointeur est déclaré sans affectation pratique dans la portée globale, il ne peut pas être réaffecté dans la portée globale. Cependant, dans ce cas, il peut être réaffecté dans une portée imbriquée.

Tableau mondial

Lorsqu'un tableau est déclaré dans la portée mondiale, il peut être vu dans une portée imbriquée. Un tableau déclaré dans une lunette imbriquée, ne peut pas être vu en dehors de la portée imbriquée. Il existe deux façons de déclarer un tableau. Un tableau peut être déclaré avec une affectation pratique (d'une adresse). Un tableau peut être déclaré sans affectation pratique. Si le tableau est déclaré sans affectation pratique dans la portée mondiale, il ne peut pas être réaffecté dans la portée mondiale. Cependant, il peut être réaffecté dans une portée imbriquée (élément par élément).

Portée du paramètre de modèle

La portée normale d'un nom de paramètre de modèle commence du point de déclaration à la fin de son bloc, comme dans l'exemple suivant:

modèle structure

T John = 11;
U peter = 12.3;
T Mary = 13;
U joie = 14.6;
;

U et t sont vus dans le bloc.

Pour un prototype de fonction de modèle, la portée commence du point de déclaration à la fin de la liste des paramètres de fonction, comme dans l'instruction suivante:

modèle void func (t non, u cha, const char * str);

Cependant, en ce qui concerne la description de la classe (définition), la portée peut également être de différentes parties, comme dans l'exemple suivant:

#inclure
Utilisation de Namespace Std;
modèle classe TheCla

public:
T num;
statique u ch;
void func (u cha, const char * str)

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

STATIC VOID FUN (U CH)

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

;
int main()

Thecla obj;
obj.num = 12;
obj.func ('$', "500");
retour 0;

Nom cachette

Un exemple de cachette de nom se produit lorsque le nom du même type d'objet est redéclaré dans un bloc imbriqué. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
void fn ()

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

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

fn ();
retour 0;

La sortie est:

4
3

C'est parce que var dans le bloc imbriqué a caché var dans le bloc extérieur.

Possibilité de répéter la déclaration dans la même portée

Le point de la déclaration est l'endroit où le nom est introduit (pour la première fois) dans sa portée.

Prototype de fonction

Différentes entités, même de types différents, ne peuvent normalement pas être déclarées dans la même portée. Cependant, un prototype de fonction peut être déclaré plus d'une fois dans la même portée. Le programme suivant avec deux prototypes de fonction et la définition de fonction correspondante illustre ceci:

#inclure
Utilisation de Namespace Std;
void fn (int num);
void fn (int num);
void fn (int num)

couter<
int main()

fn (5);
retour 0;

Le programme fonctionne.

Fonctions surchargées

Les fonctions surchargées sont des fonctions avec le même nom mais avec différentes signatures de fonction. Comme autre exception, les fonctions surchargées avec le même nom peuvent être définies dans la même portée. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
void fn (int num)

couter<
void fn (Float no)

couter<
int main()

fn (5);
float flt = 8.7;
fn (flt);
retour 0;

La sortie est:

5
8.7

Les fonctions surchargées ont été définies dans la portée globale.

Portée de l'espace de noms

Étant donné que deux variables différentes peuvent avoir le même nom et les différencier, les variables doivent être déclarées dans deux espaces de noms différents. Un espace de noms est un bloc avec un nom, ayant ses propres entités nommées. Le nom d'un espace de noms est le nom du bloc. Deux espaces de noms différents peuvent avoir des entités avec les mêmes noms. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
espace de noms na

char Ch1;
char ch2 = 'q';

Espace de noms NB

char Ch1;
char ch2 = 'y';

int main()

Na :: ch1 = 'p';
couter << NA::ch1 << endl;
Nb :: ch1 = 'x';
couter << NB::ch1 << endl;
retour 0;

La sortie est:

P
X

Il y a deux espaces de noms: NA et NB. L'espace prédéfini pour NA est son bloc. L'espace prédéfini pour NB est également son bloc. Notez que les entités des deux blocs différents ont les mêmes noms. Pour déclarer un espace de noms, commencez par le mot réservé, espace de noms; Un espace suit, puis le bloc avec ses entités.

Pour accéder à une entité en dehors du bloc d'espace de noms, commencez par le nom de l'espace de noms. Ceci est suivi par l'opérateur de résolution de portée puis le nom de l'entité.

La portée de la variable, Na :: CH1, commence à partir du point de déclaration de CH1 dans le bloc NA. Il se termine à la fin du bloc NA, puis apparaît dans n'importe quelle ligne à l'extérieur (et en dessous) du bloc, où «Na ::» est utilisé. La portée de la variable, NB :: CH1, commence à partir du point de déclaration de CH1 dans le bloc NB. Il se termine à la fin du bloc NB et apparaît dans n'importe quelle ligne à l'extérieur (et ci-dessous) le bloc, où «NB ::» est utilisé.

Une portée de l'espace de noms fait référence à une entité déclarée dans le bloc d'espace de noms. La portée de l'entité de l'espace de noms est le bloc d'espace de noms et toute ligne à l'extérieur du bloc qui utilise le nom de l'espace de noms.

Portée en différentes parties

Les lunettes de classe et d'espace de noms précédentes ont illustré comment une portée peut être dans différentes parties du texte du programme. Un autre bon exemple est le spécificateur d'ami.

Spécificateur d'amis

Si la classe C est déclarée comme un ami de la classe A, dans la définition de classe A, alors toutes les fonctions des membres publics de la classe C peuvent accéder aux membres de données privés (et fonctions membres privés) de la classe A. Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
Classe A
privé: int d = 5;
ami classe C;
;
classe B
/ *
public: int fb ()
A A;
retourner un.d;

* /
;
classe C
public: int fc ()
A A;
retourner un.d;

;
int main()

A A;
B B;
C C;
// int ret1 = b.fb ();
int ret2 = c.fc ();
couter << ret2 << endl;
retour 0;

La sortie est 5. Dans la définition de la classe A, la classe C est déclarée comme un ami de la classe A. Ainsi, FC () de la définition de classe C peut voir d de la définition de classe A. Le programme compile. Si les symboles de commentaire sont supprimés, le programme ne se compile pas car la classe B n'a pas été déclarée ami de la classe A.

La portée de la variable privée B commence à partir de son point de déclaration et se termine à la fin du bloc de classe A. Il apparaît également dans la fonction fc () dans la classe C, qui est un ami de la classe A. Les deux parties de la portée sont le bloc de classe A et le bloc fonction FC ().

Conclusion

Une portée est une région déclarative. Une région déclarative est la plus grande partie d'un texte de programme dans lequel le nom d'une entité est valide. Il peut être divisé en plus d'une partie avec certains schémas de programmation, tels que des blocs imbriqués. Les parties qui n'ont pas le point de déclaration forment la portée potentielle. La portée potentielle peut ou non avoir la déclaration.