Phenquestions
Contenu de l'article
- Région déclarative et portée
- Portée mondiale
- Portée du bloc
- Portée de la fonction
- Portée du dénombrement
- Portée de la classe
- Portée des paramètres du modèle
- Nom caché
- Possibilité de répéter la déclaration dans le même périmètre
- Portée de l'espace de noms
- Portée en différentes portions
- Conclusion
Région déclarative et portée
Une région déclarative est la plus grande partie d'un texte de programme dans laquelle le nom d'une entité est valide. C'est la région dans laquelle le nom non qualifié peut être utilisé (vu) pour faire référence à la même entité. Considérez le programme court suivant :
#inclureen utilisant l'espace de noms std ;
vide fn()
int var = 3;
si (1==1)
cout<
int main()
fn();
renvoie 0 ;
La fonction fn() a deux blocs : un bloc interne pour la condition if et un bloc externe pour le corps de la fonction. L'identifiant, var, est introduit et vu dans le bloc extérieur. On le voit aussi dans le bloc intérieur, avec l'instruction cout. Les blocs externes et internes sont à la fois la portée du nom, var.
Cependant, le nom, var, peut toujours être utilisé pour déclarer une entité différente telle qu'un flottant dans le bloc interne. Le code suivant illustre cela :
#inclureen utilisant l'espace de noms std ;
vide fn()
int var = 3;
si (1==1)
flottant var = 7.5 ;
cout<
int main()
fn();
renvoie 0 ;
La sortie est 7.5. Dans ce cas, le nom, var, ne peut plus être utilisé dans le bloc interne pour désigner l'entier de valeur 3, qui a été introduit (déclaré) dans le bloc externe. Ces blocs internes sont appelés portée potentielle pour les entités déclarées dans le bloc externe.
Remarque : Une entité du même type, comme celle du bloc externe, peut toujours être déclarée dans le bloc interne. Cependant, dans ce cas, ce qui est valable dans le bloc intérieur est la nouvelle déclaration et sa signification, tandis que l'ancienne déclaration et sa signification en dehors du bloc intérieur restent valables dans le bloc extérieur.
Une déclaration du même nom dans un bloc interne remplace normalement la déclaration du même nom en dehors de ce bloc interne. Les blocs intérieurs peuvent emboîter d'autres blocs intérieurs.
Portée mondiale
Quand un programmeur commence juste à taper un fichier, c'est la portée globale. Le programme court suivant illustre cela :
#inclureen utilisant l'espace de noms std ;
var flottante = 9.4 ;
int main()
cout <
renvoie 0 ;
La sortie est :
9.4
9.4
Dans ce cas, la région ou la portée déclarative de var commence à partir du point de déclaration de var, continue vers le bas jusqu'à la fin du fichier (unité de traduction).
Le bloc de la fonction main() a une portée différente ; c'est une portée imbriquée pour la portée globale. Pour accéder à une entité de la portée globale, depuis 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 globale.
Portée du bloc
Les instructions if, while, do, for ou switch 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 la 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 ident :
#inclureen utilisant l'espace de noms std ;
int main()
si (1==1)
/*quelques déclarations*/
int ident = 5;
cout<
renvoie 0 ;
Une variable, telle que ident, déclarée à la portée du bloc est une variable locale.
Une variable déclarée en dehors de la portée du bloc et au-dessus peut être vue dans l'en-tête du bloc (e.g., condition pour if-block) et aussi dans le bloc. Le programme court suivant illustre cela pour la variable, identif :
#inclureen utilisant l'espace de noms std ;
int main()
int identifiant = 8;
si (identifiant == 8)
cout<
renvoie 0 ;
La sortie est 8. Il y a deux portées de bloc ici : le bloc pour la fonction main() et l'instruction if-compound imbriquée. Le bloc imbriqué est la portée potentielle du bloc fonction main().
Une déclaration introduite dans une portée de bloc ne peut pas être vue en dehors du bloc. Le programme court suivant, qui ne compile pas, l'illustre avec la variable variab :
#inclureen utilisant l'espace de noms std ;
int main()
si (1 == 1)
int variable = 15 ;
cout<
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 (en dessous) de l'instruction composée. Le code de boucle for suivant ne sera pas compilé, ce qui entraînera un message d'erreur :
#inclureen utilisant l'espace de noms std ;
int main()
pour (int i=0; i<4; ++i)
cout<
cout<
La variable d'itération, i, est visible à l'intérieur du bloc de boucle for mais pas à l'extérieur du bloc de boucle for.
Portée de la fonction
Un paramètre de fonction est vu dans le bloc de fonction. Une entité déclarée dans un bloc fonction est vue depuis le point de déclaration jusqu'à la fin du bloc fonction. Le programme court suivant illustre cela :
#inclure#inclure
en utilisant l'espace de noms std ;
chaîne fn(chaîne str)
char stri[] = "bananes";
/*autres déclarations*/
chaîne totalStr = str + stri;
renvoie totalStr;
int main()
string totStr = fn("manger ");
cout<
La sortie est :
manger des bananes
Remarque : Une entité déclarée en dehors de la fonction (au-dessus) est visible dans la liste des paramètres de la fonction ainsi que dans le bloc fonction.
Étiqueter
La portée d'une étiquette est la fonction dans laquelle elle apparaît. Le code suivant illustre cela :
#inclureen utilisant l'espace de noms std ;
vide fn()
aller à l'étiquette ;
/*autres déclarations*/
labl : int entier = 2 ;
cout<
int main()
fn();
renvoie 0 ;
La sortie est 2.
Portée du dénombrement
Énumération non délimitée
Considérez le bloc if suivant :
enum a, b, c=b+2 ;
cout<
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 déclaration à la fin du bloc englobant de l'énumération.
L'instruction suivante ne sera pas compilée 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 sera pas compilé car les énumérateurs sont accessibles après le bloc englobant de l'énumération :
si (1==1)enum a, b, c=b+2 ;
cout<
Énumération de portée
La déclaration suivante est OK :
Ceci est un exemple d'énumération étendue. 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 englobant de l'énumération. Le code suivant ne compilera pas :
si (1==1)nom de classe enum a, b, c=b+2 ;
cout<
Portée de la classe
Avec une portée normale, la région déclarative commence à partir d'un point, puis continue et s'arrête à un point 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 pour les blocs imbriqués s'appliquent toujours. Le programme suivant illustre cela :
#inclureen utilisant l'espace de noms std ;
//Classe de base
classe Cla
privé:
int memP = 5;
protégé:
int memPro = 9;
Publique:
vide fn()
cout<
;
//Classe dérivée
classe DerCla : public Cla
Publique:
int derMem = memPro;
;
int main()
Cla obj;
obj.fn();
DerCla derObj;
cout<
La sortie est :
5
9
Dans la classe Cla, la variable memP, est vue au point de déclaration. Après cela, la partie courte de « protected » est ignorée, puis réexaminée dans le bloc fonction membre de classe. La classe dérivée est ignorée, puis réexaminée au niveau de la portée de la fonction main() (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 en bas dans la fonction main().
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 cela :
en utilisant l'espace de noms std ;
classe Cla
Publique:
static int const mem = 5;
Publique:
vide statique fn()
cout<
;
int main()
cout<
renvoie 0 ;
La sortie est :
5
5
Les membres statiques sont visibles dans le bloc fonction main(), accessible à l'aide de l'opérateur de résolution de portée.
Portée des paramètres du 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 le code suivant :
modèleT Jean = 11 ;
U Pierre = 12.3 ;
T Marie = 13 ;
U joie = 14.6 ;
;
U et T sont vus dans le bloc.
Pour un prototype de fonction modèle, la portée commence du point de déclaration à la fin de la liste des paramètres de la fonction, comme dans l'instruction suivante :
modèleCependant, en ce qui concerne la description de la classe (définition), la portée peut également être de différentes parties comme dans le code suivant :
#inclureen utilisant l'espace de noms std ;
modèle
Publique:
T num;
statique U ch;
void func (U cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
amusement du vide statique (U ch)
si (ch == 'a')
cout << "Official static member function" << '\n';
;
int main()
La Cla
obj.nombre = 12 ;
obj.func('$', "500");
renvoie 0 ;
Nom caché
Un exemple de masquage de nom se produit lorsque le nom du même type d'objet est à nouveau déclaré dans un bloc imbriqué. Le programme suivant illustre cela :
#inclureen utilisant l'espace de noms std ;
vide fn()
int var = 3;
si (1==1)
int var = 4;
cout<
cout<
int main()
fn();
renvoie 0 ;
La sortie est :
4
3
C'est parce que var dans le bloc imbriqué cachait var dans le bloc extérieur.
Possibilité de répéter la déclaration dans le même périmètre
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
Des entités différentes, même de types différents, ne peuvent normalement pas être déclarées dans le même périmètre. Cependant, un prototype de fonction peut être déclaré plusieurs fois dans la même portée. Le programme suivant avec deux prototypes de fonction et la définition de fonction correspondante illustre cela :
en utilisant l'espace de noms std ;
void fn(int num);
void fn(int num);
void fn(int num)
cout<
int main()
nf(5) ;
renvoie 0 ;
Le programme fonctionne.
Fonctions surchargées
Les fonctions surchargées sont des fonctions portant le même nom mais des signatures de fonction différentes. 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 cela :
en utilisant l'espace de noms std ;
void fn(int num)
cout<
void fn (flotteur non)
cout<
int main()
nf(5) ;
flotteur flt = 8.7;
fn(flt);
renvoie 0 ;
La sortie est :
5
8.7
Les fonctions surchargées ont été définies dans le périmètre global.
Portée de l'espace de noms
Namespace Scope mérite son propre article. Ledit article a été écrit pour ce site, linuxhint.com. Tapez simplement les mots de recherche "Namespace Scope" dans la zone de recherche de ce site (page) et cliquez sur OK, et vous obtiendrez l'article.
Portée en différentes portions
La classe n'est pas le seul schéma où la portée peut être dans différentes parties. Le spécificateur ami, certaines utilisations du spécificateur de type élaboré et les directives d'utilisation sont d'autres schémas où la portée est à des endroits différents - pour plus de détails, voir plus loin.
Conclusion
Un scope est une région déclarative. Une région déclarative est la plus grande partie d'un texte de programme dans laquelle le nom d'une entité est valide. Il peut être divisé en plusieurs parties conformément à certains schémas de programmation, tels que les blocs imbriqués. Les portions 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.
