Alcance en C ++

Una entidad en C ++ tiene un nombre, que se puede declarar y / o definir. Una declaración es una definición, pero una definición no es necesariamente una declaración. Una definición asigna memoria para la entidad nombrada, pero una declaración puede o no asignar memoria para la entidad nombrada. Una región declarativa es la parte más grande de un programa en la que el nombre de una entidad (variable) es válido. Esa región se llama ámbito o ámbito potencial. Este artículo explica el alcance en C++. Además, se necesitan conocimientos básicos en C ++ para comprender este artículo.

Contenido del artículo

Región declarativa y alcance
Alcance global
Alcance del bloque
Alcance de la función
Alcance de la enumeración
Alcance de la clase
Alcance del parámetro de plantilla
Ocultar nombre
Posibilidad de repetir declaración en el mismo ámbito
Alcance del espacio de nombres
Alcance en diferentes porciones
Conclusión

Región declarativa y alcance

Una región declarativa es la parte más grande del texto de un programa en la que el nombre de una entidad es válido. Es la región en la que se puede usar (ver) el nombre no calificado para referirse a la misma entidad. Considere el siguiente programa corto:

#incluir
usando el espacio de nombres std;
vacío fn ()

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

cout<

int main ()

fn ();
return 0;

La función fn () tiene dos bloques: un bloque interno para la condición if y un bloque externo para el cuerpo de la función. El identificador, var, se introduce y se ve en el bloque exterior. También se ve en el bloque interior, con la declaración cout. Los bloques exterior e interior son el alcance del nombre, var.

Sin embargo, el nombre, var, todavía se puede usar para declarar una entidad diferente, como un flotante en el bloque interno. El siguiente código ilustra esto:

#incluir
usando el espacio de nombres std;
vacío fn ()

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

float var = 7.5;
cout<

int main ()

fn ();
return 0;

La salida es 7.5. En este caso, el nombre, var, ya no se puede usar en el bloque interno para hacer referencia al número entero de valor 3, que se introdujo (declaró) en el bloque externo. Dichos bloques internos se denominan alcance potencial para las entidades declaradas en el bloque externo.

Nota: una entidad del mismo tipo, como la del bloque exterior, todavía se puede declarar en el bloque interior. Sin embargo, en este caso, lo que es válido en el bloque interno es la nueva declaración y su significado, mientras que la declaración anterior y su significado fuera del bloque interno siguen siendo válidos en el bloque externo.

Una declaración del mismo nombre en un bloque interno normalmente anula la declaración del mismo nombre fuera de ese bloque interno. Los bloques internos pueden anidar otros bloques internos.

Alcance global

Cuando un programador comienza a escribir un archivo, ese es el alcance global. El siguiente programa corto ilustra esto:

#incluir
usando el espacio de nombres std;
float var = 9.4;
int main ()

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

La salida es:
9.4
9.4

En este caso, la región declarativa o el alcance de var comienza desde el punto de declaración de var, continúa hacia abajo hasta el final del archivo (unidad de traducción).

El bloque de la función main () tiene un alcance diferente; es un ámbito anidado para el ámbito global. Para acceder a una entidad del alcance global, desde un alcance diferente, el identificador se usa directamente o precedido por el operador de resolución del alcance,: .

Nota: La entidad, main (), también se declara en el alcance global.

Alcance del bloque

Las sentencias if, while, do, for o switch pueden definir cada una un bloque. Tal declaración es una declaración compuesta. El nombre de una variable declarada en un bloque tiene el alcance de un bloque. Su alcance comienza en su punto de declaración y termina al final de su bloque. El siguiente programa corto ilustra esto para la variable, ident:

#incluir
usando el espacio de nombres std;
int main ()

si (1 == 1)

/ * algunas declaraciones * /
int ident = 5;
cout</ * algunas declaraciones * /

return 0;

Una variable, como ident, declarada en el alcance del bloque es una variable local.

Una variable declarada fuera del alcance del bloque y por encima de ella se puede ver en el encabezado del bloque (e.gramo., condición para if-block) y también dentro del bloque. El siguiente programa corto ilustra esto para la variable, identif:

#incluir
usando el espacio de nombres std;
int main ()

int identif = 8;
si (identif == 8)

cout<
return 0;

La salida es 8. Aquí hay dos ámbitos de bloque: el bloque para la función main () y la instrucción if-compuesta anidada. El bloque anidado es el alcance potencial del bloque de función main ().

Una declaración introducida en un alcance de bloque no se puede ver fuera del bloque. El siguiente programa corto, que no se compila, ilustra esto con la variable, variab:

#incluir
usando el espacio de nombres std;
int main ()

si (1 == 1)

int variab = 15;

cout<return 0;

El compilador produce un mensaje de error para variab.

Una entidad introducida, declarada en el encabezado de una función compuesta, no puede verse fuera (debajo) de la declaración compuesta. El siguiente código de bucle for no se compilará, lo que dará como resultado un mensaje de error:

#incluir
usando el espacio de nombres std;
int main ()

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

cout<
cout<return 0;

La variable de iteración, i, se ve dentro del bloque for-loop pero no fuera del bloque for-loop.

Alcance de la función

Un parámetro de función se ve en el bloque de función. Una entidad declarada en un bloque de funciones se ve desde el punto de declaración hasta el final del bloque de funciones. El siguiente programa corto ilustra esto:

#incluir
#incluir
usando el espacio de nombres std;
cadena fn (cadena str)

char Stri [] = "plátanos";
/ * otras declaraciones * /
string totalStr = str + Stri;
return totalStr;

int main ()

cadena totStr = fn ("comiendo");
cout<return 0;

La salida es:
comiendo bananas

Nota: una entidad declarada fuera de la función (encima de ella) se puede ver en la lista de parámetros de la función y también en el bloque de funciones.

Etiqueta

El alcance de una etiqueta es la función en la que aparece. El siguiente código ilustra esto:

#incluir
usando el espacio de nombres std;
vacío fn ()

goto labl;
/ * otras declaraciones * /
labl: int inte = 2;
cout<
int main ()

fn ();
return 0;

La salida es 2.

Alcance de la enumeración

Enumeración sin ámbito
Considere el siguiente bloque if:

si (1 == 1)

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

La salida es 0 1 3.

La primera línea del bloque es una enumeración, a, byc son sus enumeradores. El alcance de un enumerador comienza desde el punto de declaración hasta el final del bloque adjunto de la enumeración.

La siguiente declaración no se compilará porque el punto de declaración de c es posterior al de a:

enum a = c + 2, b, c;

El siguiente segmento de código no se compilará porque se accede a los enumeradores después del bloque adjunto de la enumeración:

si (1 == 1)

enum a, b, c = b + 2;

cout<La enumeración anterior se describe como una enumeración sin ámbito y sus enumeradores se describen como enumeradores sin ámbito. Esto se debe a que comienza solo con la palabra reservada, enum. Las enumeraciones que comienzan con la clase enum o la estructura enum se describen como enumeraciones con ámbito. Sus enumeradores se describen como enumeradores de ámbito.

Enumeración con ámbito
La siguiente declaración está bien:

enumeración clase nam a, b, c = b + 2;

Este es un ejemplo de una enumeración con ámbito. El nombre de la clase es nam. Aquí, el alcance del enumerador comienza desde el punto de declaración hasta el final de la definición de enumeración, y no el final del bloque adjunto para la enumeración. El siguiente código no se compilará:

si (1 == 1)

enumeración clase nam a, b, c = b + 2;
cout<

Alcance de la clase

Con el alcance normal, la región declarativa comienza desde un punto, luego continúa y se detiene en un punto diferente. El alcance existe en una región continua. Con la clase, el alcance de una entidad puede estar en diferentes regiones que no están unidas. Las reglas para bloques anidados todavía se aplican. El siguiente programa ilustra esto:

#incluir
usando el espacio de nombres std;
// Clase base
clase Cla

privado:
int memP = 5;
protegido:
int memPro = 9;
público:
vacío fn ()

cout<
;
//Clase derivada
clase DerCla: public Cla

público:
int derMem = memPro;
;
int main ()

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

La salida es:
5
9

En la clase Cla, la variable memP, se ve en el punto de declaración. Después de eso, se omite la parte corta de "protected" y luego se vuelve a ver en el bloque de funciones del miembro de clase. La clase derivada se omite y luego se vuelve a ver en el alcance de la función main () (bloque).

En la clase Cla, la variable memPro, se ve en el punto de declaración. La parte de la función pública fn () se omite y luego se ve en el bloque de descripción de la clase derivada. Se ve nuevamente hacia abajo en la función main ().

Operador de resolución de alcance
El operador de resolución de alcance en C ++ es: . Se utiliza para acceder a un miembro estático de la clase. El siguiente programa ilustra esto:

#incluir
usando el espacio de nombres std;
clase Cla

público:
static int const mem = 5;
público:
vacío estático fn ()

cout<
;
int main ()

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

La salida es:
5
5

Los miembros estáticos se ven en el bloque de funciones main (), al que se accede mediante el operador de resolución de alcance.

Alcance del parámetro de plantilla

El alcance normal de un nombre de parámetro de plantilla comienza desde el punto de declaración hasta el final de su bloque, como en el siguiente código:

plantilla Edades de estructura

T John = 11;
U Peter = 12.3;
T María = 13;
U Alegría = 14.6;
;

U y T se ven dentro del bloque.

Para un prototipo de función de plantilla, el alcance comienza desde el punto de declaración hasta el final de la lista de parámetros de función, como en la siguiente declaración:

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

Sin embargo, cuando se trata de la descripción de la clase (definición), el alcance también puede ser de diferentes partes como en el siguiente código:

#incluir
usando el espacio de nombres std;
plantilla clase TheCla

público:
T num;
estático U ch;
void func (U cha, const char * str)

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

diversión del vacío estático (U ch)

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

;
int main ()

TheCla obj;
obj.num = 12;
obj.func ('$', "500");
return 0;

Ocultar nombre

Un ejemplo de ocultación de nombres ocurre cuando el nombre del mismo tipo de objeto se vuelve a declarar en un bloque anidado. El siguiente programa ilustra esto:

#incluir
usando el espacio de nombres std;
vacío fn ()

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

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

fn ();
return 0;

La salida es:
4
3

Es porque var en el bloque anidado escondió var en el bloque exterior.

Posibilidad de repetir declaración en el mismo ámbito

El punto de la declaración es donde se introduce el nombre (por primera vez) en su ámbito.

Prototipo de función
Diferentes entidades, incluso de diferentes tipos, normalmente no pueden declararse en el mismo ámbito. Sin embargo, un prototipo de función se puede declarar más de una vez en el mismo ámbito. El siguiente programa con dos prototipos de función y la definición de función correspondiente ilustra esto:

#incluir
usando el espacio de nombres std;
void fn (int num);
void fn (int num);
void fn (int num)

cout<
int main ()

fn (5);
return 0;

El programa funciona.

Funciones sobrecargadas
Las funciones sobrecargadas son funciones con el mismo nombre pero diferentes firmas de función. Como otra excepción, las funciones sobrecargadas con el mismo nombre se pueden definir en el mismo ámbito. El siguiente programa ilustra esto:

#incluir
usando el espacio de nombres std;
void fn (int num)

cout<
void fn (flotar no)

cout<
int main ()

fn (5);
flotador flt = 8.7;
fn (flt);
return 0;

La salida es:
5
8.7

Las funciones sobrecargadas se han definido en el ámbito global.

Alcance del espacio de nombres

El ámbito del espacio de nombres merece su propio artículo. Dicho artículo ha sido escrito para este sitio web, linuxhint.com. Simplemente escriba las palabras de búsqueda "Ámbito del espacio de nombres" en el cuadro de búsqueda de este sitio (página) y haga clic en Aceptar, y obtendrá el artículo.

Alcance en diferentes porciones

La clase no es el único esquema donde el alcance puede estar en diferentes porciones. El especificador amigo, ciertos usos del especificador de tipo elaborado y las directivas de uso son otros esquemas en los que el alcance está en diferentes lugares; para obtener más detalles, consulte más adelante.

Conclusión

Un ámbito es una región declarativa. Una región declarativa es la parte más grande del texto de un programa en la que el nombre de una entidad es válido. Se puede dividir en más de una parte de acuerdo con ciertos esquemas de programación, como bloques anidados. Las porciones que no tienen el punto de declaración forman el alcance potencial. El alcance potencial puede tener o no la declaración.