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
utilizando espacio de nombreshoras;
vacíofn()
{
En tdónde= 3;
si (1==1)
{
costo<<dónde<<' orte';
}
}
En tprincipal()
{
fn();
regreso 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 externo e interno 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
utilizando espacio de nombreshoras;
vacíofn()
{
En tdónde= 3;
si (1==1)
{
flotadordónde= 7.5;
costo<<dónde<<' orte';
}
}
En tprincipal()
{
fn();
regreso 0;
}
La salida es 7.5. En este caso, el nombre, var, ya no se puede usar en el bloque interno para referirse al número entero de valor 3, que fue introducido (declarado) 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 externo, aún se puede declarar en el bloque interno. 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:
#incluirutilizando espacio de nombreshoras;
flotadordónde= 9.4;
En tprincipal()
{
costo <<dónde<<' orte';
costo <<::dónde<<' orte';
regreso 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 ámbito global, desde un ámbito diferente, el identificador se usa directamente o precedido por el operador de resolución del ámbito, ::.
Nota: La entidad, main (), también se declara en el alcance global.
Alcance del bloque
Cada una de las sentencias if, while, do, for o switch puede definir 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:
#incluirutilizando espacio de nombreshoras;
En tprincipal()
{
si (1==1)
{
/ * algunas declaraciones * /
En tident= 5;
costo<<ident<<' orte';
/ * algunas declaraciones * /
}
regreso 0;
}
Una variable, como ident, declarada en el ámbito 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 (por ejemplo, condición para if-block) y también dentro del bloque. El siguiente programa corto ilustra esto para la variable identif:
#incluirutilizando espacio de nombreshoras;
En tprincipal()
{
En tidentif= 8;
si (identif== 8)
{
costo<<identif<<' orte';
}
regreso 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:
#incluirutilizando espacio de nombreshoras;
En tprincipal()
{
si (1 == 1)
{
En tvariab= 15;
}
costo<<variab<<' orte'; // error: accedido fuera de su alcance.
regreso 0;
}
El compilador genera 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:
#incluirutilizando espacio de nombreshoras;
En tprincipal()
{
por (En tI=0;I<4; ++I)
{
costo<<I<<' ';
}
costo<<I<<' ';
regreso 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 funciones. 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
utilizando espacio de nombreshoras;
cadena fn(cadena str)
{
carbonizarseStri[] = 'plátanos';
/ * otras declaraciones * /
string totalStr=pag+Stri;
regresototalStr;
}
En tprincipal()
{
cadena totStr=fn('comiendo ');
costo<<totStr<<' orte';
regreso 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:
#incluirutilizando espacio de nombreshoras;
vacíofn()
{
ir alabl;
/ * otras declaraciones * /
labl: En tno= 2;
costo<<no<<' orte';
}
En tprincipal()
{
fn();
regreso 0;
}
La salida es 2.
Alcance de la enumeración
Enumeración sin ámbito
Considere el siguiente bloque if:
{
enumeración {a B C=b+2};
costo<<a<<' '<<b<<' '<<c<<' orte';
}
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:
enumeración {a=c+2, antes de Cristo};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){
enumeración {a B C=b+2};
}
costo<<a<<' '<<b<<' '<<c<<' orte'; // error: fuera de alcance
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 una clase de enumeración o una estructura de enumeración se describen como enumeraciones de ámbito. Sus enumeradores se describen como enumeradores de ámbito.
Enumeración con ámbito
La siguiente declaración está bien:
Este es un ejemplo de 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 clasemasculino{a B C=b+2};
costo<<a<<' '<<b<<' '<<c<<' orte'; // error: fuera del alcance de la clase de enumeración o estructura de enumeración
}
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 aún se aplican. El siguiente programa ilustra esto:
#incluirutilizando espacio de nombreshoras;
// Clase base
claseCla
{
privado:
En tMEMORIA= 5;
protegido:
En tmemPro= 9;
público:
vacíofn()
{
costo<<MEMORIA<<' orte';
}
};
//Clase derivada
claseDerCla: públicoCla
{
público:
En tderMem=memPro;
};
En tprincipal()
{
Cla obj;
obj.fn();
DerCla derObj;
costo<<derObj.derMem<<' orte';
regreso 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 (bloque) de la función main ().
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:
utilizando espacio de nombreshoras;
claseCla
{
público:
estático En t constantememes= 5;
público:
estático vacíofn()
{
costo<<memes<<' orte';
}
};
En tprincipal()
{
costo<<Cla::memes<<' orte';
Cla::fn();
regreso 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<escribe un nombreT,escribe un nombreU> estructuraSiglos{
T John= 11;
Tu 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<escribe un nombreT,escribe un nombreU> vacíofunción(T no, U cha,constante carbonizarse *pag);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:
#incluirutilizando espacio de nombreshoras;
plantilla<claseT,claseU> claseTheCla
{
público:
t num;
estáticoU ch;
vacíofunción(U padreconstante carbonizarse *pag)
{
costo << 'Existen ' <<en uno<< 'libros que valen' <<no<<pag<< ' en la tienda.' << ' orte';
}
estático vacíodivertida(U ch)
{
si (ch== 'a')
costo << 'Función oficial de miembro estático' << ' orte';
}
};
En tprincipal()
{
TheCla<En t,carbonizarse>obj;
obj.en uno = 12;
obj.función('$','500');
regreso 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:
#incluirutilizando espacio de nombreshoras;
vacíofn()
{
En tdónde= 3;
si (1==1)
{
En tdónde= 4;
costo<<dónde<<' orte';
}
costo<<dónde<<' orte';
}
En tprincipal()
{
fn();
regreso 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 alcance.
Prototipo de función
Normalmente, las distintas entidades, incluso de diferentes tipos, 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:
utilizando espacio de nombreshoras;
vacíofn(En ten uno);
vacíofn(En ten uno);
vacíofn(En ten uno)
{
costo<<en uno<<' orte';
}
En tprincipal()
{
fn(5);
regreso 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:
utilizando espacio de nombreshoras;
vacíofn(En ten uno)
{
costo<<en uno<<' orte';
}
vacíofn(flotadorno)
{
costo<<no<<' orte';
}
En tprincipal()
{
fn(5);
flotadorflt= 8.7;
fn(flt);
regreso 0;
}
La salida es:
5
8.7
Las funciones sobrecargadas se han definido en el ámbito global.
Alcance del espacio de nombres
Namespace Scope 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 de 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 partes que no tienen el punto de declaración forman el alcance potencial. El alcance potencial puede tener o no la declaración.