Las
sentencias de decisión o también llamadas de CONTROL DE FLUJO son estructuras
de control que realizan una pregunta la cual retorna verdadero o falso (evalúa
una condición) y selecciona la siguiente instrucción a ejecutar dependiendo la
respuesta o resultado.
En
algún momento dentro de nuestros algoritmos, es preciso cambiar el flujo de
ejecución de las instrucciones, es decir, el orden en que las instrucciones son
ejecutadas. Muchas de las veces tenemos que tomar una decisión en cuanto a que
se debe ejecutar basándonos en una respuesta de verdadero o falso (condición).
La
ejecución de las instrucciones incluyendo una estructura de control como el
condicional funciona de esta manera:
Las
instrucciones comienzan a ejecutarse de forma secuencial (en orden) y cuando se
llega a una estructura condicional, la cual está asociada a una condición, se
decide qué camino tomar dependiendo siempre del resultado de la condición
siendo esta falsa o verdadera.
Cuando
se termina de ejecutar este bloque de instrucciones se reanuda la ejecución en
la instrucción siguiente a la de la condicional.
SENTENCIA IF
La instrucción if es,
por excelencia, la más utilizada para construir estructuras de control de
flujo.
SINTAXIS
Primera Forma
Ahora bién, la
sintaxis utilizada en la programación de C++ es la siguiente:
if (condición)
{
Set de instrucciones
}
|
Siendo
"condición" el lugar donde se pondrá la condición que se tiene que
cumplir para que sea verdadera la sentencia y así proceder a realizar el
"set de instrucciones" o código contenido dentro de la sentencia.
Segunda Forma
Ahora veremos la misma
sintaxis pero ahora le añadiremos la parte "Falsa" de la sentencia:
if (condición)
{
Set de instrucciones //PARTE VERDADERA
}
else
{
Set de instrucciones 2 //Parte FALSA
}
|
La forma mostrada
anteriormente muestra la unión de la parte "VERDADERA" con la nueva
secuencia la cual es la parte "FALSA" de la sentencia de decisión
"IF" en la cual está compuesta por el:
else
{
Set de
instrucciones 2 //Parte FALSA
}
|
La palabra
"else" o "De lo contrario" indica al lenguaje que de lo
contrario al no ser verdadera o no se cumpla la parte verdadera entonces
realizara el "set de instrucciones 2".
EJEMPLOS
DE SENTENCIAS IF...
Ejemplo 1:
if(numero == 0) //La condicion indica que tiene que ser
igual a Cero
{
cout<<"El Numero Ingresado es Igual a Cero";
}
|
SENTENCIA SWITCH
Switch es otra de las
instrucciones que permiten la construcción de estructuras de control. A
diferencia de if, para controlar el flujo por medio de una sentencia switch se
debe de combinar con el uso de las sentencias case y break.
Notas: cualquier
número de casos a evaluar por switch así como la sentencia default son
opcionales. La sentencia switch es muy útil en los casos de presentación de
menús.
Sintaxis:
switch (condición)
{
case
primer_caso:
bloque de
instrucciones 1
break;
case
segundo_caso:
bloque de
instrucciones 2
break;
case caso_n:
bloque de
instrucciones n
break;
default: bloque
de instrucciones por defecto
}
|
Ejemplo 1
switch (numero)
{
case 0: cout
<< "numero es cero";
}
|
Ejemplo 2
switch (opcion)
{
case 0: cout
<< "Su opcion es cero"; break;
case 1: cout
<< "Su opcion es uno"; break;
case 2: cout
<< "Su opcion es dos";
}
|
Ejemplo 3
switch (opcion)
{
case 1: cout
<< "Su opcion es 1"; break;
case 2: cout
<< "Su opcion es 2"; break;
case 3: cout
<< "Su opcion es 3"; break;
default: cout
<< "Elija una opcion entre 1 y 3";
}
|
Operador condicional
ternario?:
En C/C++, existe el
operador condicional ( ?: ) el cual es conocido por su estructura como ternario.
El comportamiento de dicho operador es el mismo que una estructura if - then -
else del lenguaje BASIC (y de la función IIf de Visual Basic). El operador
condicional?: es útil para evaluar situaciones tales como:
Si se cumple tal
condición entonces haz esto, de lo contrario haz esto otro.
Sintaxis:
( (condicion) ? proceso1 : proceso2 )
|
En donde, condicion es
la expresión que se evalua, proceso1 es la tarea a realizar en el caso así
también se conoce caridad de que la evaluación resulte verdadera, y proceso2 es
la tarea a realizar en el caso de que la evaluación o negativa resulte falsa.
Ejemplo 1
int edad;
cout << "Cual es tu edad: ";
cin >> edad;
cout << ( (edad < 18) ? "Eres joven
aun" : "Ya tienes la mayoría de edad" );
|
El ejemplo anterior
podría escribirse de la siguiente manera:
int edad;
cout << "Cual es tu edad: ";
cin >> edad;
if (edad < 18) cout << "Eres joven
aun";
else cout
<< "Ya tienes la mayoría de edad";
|
SENTENCIAS DE ITERACIÓN
DEFINICIÓN
Las Sentencias de Iteración o Ciclos son estructuras de
control que repiten la ejecución de un grupo de instrucciones. Básicamente, una
sentencia de iteración es una estructura de control condicional, ya que dentro
de la misma se repite la ejecución de una o más instrucciones mientras que una
a condición específica se cumpla. Muchas veces tenemos que repetir un número
definido o indefinido de veces un grupo de instrucciones por lo que en estos
casos utilizamos este tipo de sentencias. en C++ los ciclos o bucles se
construyen por medio de las sentencias for, while y do - while. La sentencia
for es útil para los casos en donde se conoce de antemano el número de veces
que una o más sentencias han de repetirse. Por otro lado, la sentencia while es
útil en aquellos casos en donde no se conoce de antemano el número de veces que
una o más sentencias se tienen que repetir.
Sentencias For
for(contador; final; incremento)
{
Codigo a
Repetir;
}
|
Donde:
contador es una
variable numérica
final es la condición
que se evalua para finalizar el ciclo (puede ser independiente del contador)
incremento es el valor
que se suma o resta al contador
Hay que tener en
cuenta que el "for" evalua la condición de finalización igual que el
while, es decir, mientras esta se cumpla continuaran las repeticiones.
Ejemplo 1:
for(int i=1; i<=10; i++)
{
cout<<"Hola Mundo";
}
|
Sentencia while
while(condicion)
{
código a Repetir
}
|
Donde:
Condición es la
expresión a evaluar
int contador = 0;
while(contador<=10)
{
contador=contador+1;
cout<<"Hola Mundo";
}
|
Sentencia do – while
La sentencia do es
usada generalmente en cooperación con while para garantizar que una o más
instrucciones se ejecuten al menos una vez. Por ejemplo, en la siguiente
construcción no se ejecuta nada dentro del ciclo while, el hecho es que el
contador inicialmente vale cero y la condición para que se ejecute lo que está
dentro del while es "mientras el contador sea mayor que diez". Es
evidente
que a la primera evaluación hecha por while la condición deja de
cumplirse.
int contador = 0;
while(contador > 10)
{
contador ++;
cout<<"Hola Mundo";
}
|
Al modificar el
segmento de código anterior usando do tenemos:
int contador = 0;
do
{
contador ++;
cout<<"Hola Mundo";
}
while(contador > 10);
|
Observe cómo en el
caso de do la condición es evaluada al final en lugar de al principio del
bloque de instrucciones y, por lo tanto, el código que le sigue al do se
ejecuta al menos la primera vez.
SENTENCIAS BREAK Y CONTINUE
En la sección
(Sentencia switch) vimos que la sentencia break es utilizada con el propósito
de forzar un salto dentro del bloque switch hacia el final del mismo. En esta
sección volveremos a ver el uso de break, salvo que esta ocasión la usaremos
junto con las sentecias for y la sentencia while. Además, veremos el uso de la
sentencia continue.
break
La sentencia break se
usa para forzar un salto hacia el final de un ciclo controlado por for o por
while.
Ejemplo:
En el siguiente
fragmento de código la sentencia break cierra el ciclo for cuando la variable (
i ) es igual a 5. La salida para el mismo será:
0 1 2 3 4
for (int i=0; i<10; i++) {
if (i == 5)
break;
cout << i
<< " ";
}
|
continúe
La sentencia continúe
se usa para ignorar una iteración dentro de un ciclo controlado por for o por
while.
Ejemplo:
En el siguiente
fragmento de código la sentencia continúe ignora la iteración cuando la
variable ( i ) es igual a 5. La salida para el mismo será:
0 1 2 3 4 6 7 8 9
for (int i=0; i<10; i++) {
if (i == 5)
continue;
cout << i
<< " ";
}
|
Uso de break y
continue junto con while
Los dos ejemplos
anteriores se presentan en seguida, salvo que en lugar de for se hace uso de
while.
Nota: no deje de
observar que la construcción del ciclo while para el caso de la sentencia
continue es diferente, esto para garantizar que el ciclo no vaya a caer en una
iteración infinita.
Break
int i = 0;
while (i<10) {
if (i == 5)
break;
cout << i
<< " ";
i++;
}
|
Continúe
int i = -1;
while (i<10) {
i++;
if (i == 5)
continue;
cout << i
<< " ";
}
|
