0
Etiquetas
Los programas C++ se ejecutan secuencialmente, es decir, las sentencias se ejecutan una a continuación de otra, en el mismo orden en que están escritas en el programa.
Sin embargo, esta secuencia puede ser interrumpida de varias maneras, mediante el uso de sentencias de salto.
Las etiquetas son la forma en que se indica al compilador en qué puntos será reanudada la ejecución de un programa cuando se produzca una ruptura del orden secuencial de ejecución.
Etiquetas de identificación
Corresponden con la siguiente sintaxis:
| <identificador>: <sentencia> |
Estas etiquetas sirven como puntos de entrada para la sentencia de salto goto, que veremos más abajo, y tienen el ámbito restringido a la función dentro de la cual están definidas. Veremos su uso con más detalle al analizar la sentencia goto.
Etiquetas case y default
Esta etiqueta se circunscribe al ámbito de la sentencia switch, y se verá su uso en el siguiente apartado. Sintaxis:
|
switch(<variable>)
{
case <expresión_constante>: [<sentencias>][break;]
. . .
[default: [<sentencias>]]
}
|
Selección
Las sentencias de selección permiten controlar el flujo del programa, seleccionando distintas sentencias en función de diferentes circunstancias.
Sentencia if...else
Permite la ejecución condicional de una sentencia. Sintaxis:
|
if (<condición>) <sentencia1>
[else <sentencia2>] |
En C++ se pueden declarar variables dentro de la expresión de condición, que será, como en el caso de los bucles, una expresión booleana. Por ejemplo:
| if(int val = func(arg))... |
En este caso, la variable val sólo será accesible dentro del ámbito de la sentencia if y, si existe, del else.
Si la condición es verdadera se ejecutará la sentencia1, si es falsa, (y si existe la parte del else), se ejecutará la sentencia2.
La claúsula else es opcional, y si se usa, no pueden insertarse sentencias entre la sentencia1 y el else.
Sentencia switch
Esta sentencia es una generalización de las sentencias if...else. En el caso de las sentencias if, la expresión que se evalúa como condición es booleana, lo que quiere decir que sólo hay dos valores posibles, y por lo tanto, sólo se puede elegir entre dos sentencias a ejecutar.
En el caso de la sentencia switch, la expresión a evaluar será entera, por lo tanto, el número de opciones es mucho mayor, y en consecuencia, también es mayor el número de diferentes sentencias que se pueden ejecutar.
Sintaxis:
|
switch (<expresión entera>)
{
[case <expresión_constante1>: [<sentencias1>]]
[case <expresión_constante2>: [<sentencias2>]]
...
[case <expresión_constanten>: [<sentenciasn>]]
[default : [<sentencia>]]
} |
Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con el case cuya expresión constante coincida con el valor de la expresión entera evaluada dentro del switch. A partir de ese punto todas las sentencias serán ejecutadas hasta el final del switch, es decir hasta llegar al "}". Esto es así porque las etiquetas sólo marcan los puntos de entrada después de una ruptura de la secuencia de ejecución, pero no marcan los puntos de salida.
Esta estructura está diseñada para ejecutar cierta secuencia de instrucciones, empezando a partir de un punto diferente, en función de un valor entero y dejando sin ejecutar las anteriores a ese punto.
Veamos un ejemplo. Para hacer un pan hay que seguir (en una versión resumida), la siguiente secuencia:
-1.Conseguir las semillas de trigo
-2.Arar el campo
-3.Sembrar el trigo
-4.Esperar a que madure (No soy agricultor, pero sospecho que esta etapa es algo más complicada).
-5.Cosechar el trigo
-6.Separar el grano de la paja
-7.Moler el grano, para coseguir harina
-8.Amasar la harina junto con agua, sal y levadura. (Dejaremos de momento de lado el método para conseguir estos ingredientes).
-9.Dejar reposar la masa
-10Encender el horno. (También dejaremos de momento los métodos para conseguir leña, construir un horno, o encenderlo).
-11.Meter el pan crudo en el horno.
-12.Esperar a que se haga el pan.
-13.Sacar el pan del horno.
A cada paso le hemos asignado un número entero. Si por ejemplo, tenemos que hacer un pan, pero ya hemos hecho los primeros siete pasos, es decir, disponemos de harina, la ejecución empezará en el paso ocho, y continuará hasta el trece. De forma análoga, si ya tenemos masa dejada a reposar, podremos entrar directamente en el nivel diez.
Esta característica también nos permite ejecutar las mismas sentencias para varias etiquetas distintas, y en el apartado siguiente veremos (aunque vamos a adelantarlo ahora) que se puede eludir la ejecución secuencial normal usando la sentencia de ruptura break para ejecutar sólo parte de las sentencias.
Si el valor de la expresión entera no satisface ningún case, es decir, si no existe un case con una expresión constante igual al valor de la expresión entera, el control parará a la sentencia etiquetada con la etiqueta default.
Todas las etiquetas son opcionales, tanto default como todos los case. Si no se satisface ningún case, ni aparece la etiqueta default, se abandonará la sentencia switch sin ejecutar ninguna sentencia.
Por ejemplo:
|
bool EsVocal;
char letra;
...
switch(letra)
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
EsVocal = true;
break;
default:
EsVocal = false;
} |
En este ejemplo letra es una variable de tipo char y EsVocal de tipo bool. Si el valor de entrada en el switch corresponde a una vocal, EsVocal saldrá con un valor verdadero, en caso contrario, saldrá con un valor falso. El ejemplo ilustra el uso del break. Si por ejemplo, letra contiene el valor 'a', se cumple el primer case, y la ejecución continúa en la siguiente sentencia: EsVocal = true, ignorando el resto de los case hasta el break, que nos hace abandonar la sentencia switch.
Otro ejemplo:
|
int Menor1, Menor2, Menor3, Mayor3;
Menor1 = Menor2 = Menor3 = Mayor3 = false;
switch(numero)
{
case 0:
Menor1 = true;
case 1:
Menor2 = true;
case 2:
Menor3 = true;
break;
default:
Mayor3 = true;
} |
Veamos qué pasa en este ejemplo si numero vale 1. Directamente se reanuda la ejecución en case 1:, con lo cual Menor2 tomará el valor true, lo mismo pasará con Menor3. Después aparece el break y se abandona la sentencia switch.
Recordemos que los tipos enumerados se consideran también como enteros, de modo que también es posible usarlos en sentencias switch, de hecho, su uso en estas sentencias es bastante frecuente.
|
enum estado {principio, primera, segunda, tercera, final};
estado x;
x = primera;
switch(x) {
case principio: IniciarProceso();
case primera: PrimeraFase();
case segunda: SegundaFase();
case tercera: TerceraFase();
case final: Terminar()
} |
Comentarios