INSTRUCCIONES DE CONTROL

CONTENIDOS

1. Introducción a las sentencias de control.

2. Instrucciones o sentencias condicionales: IF, IF-ELSE, SWITCH.

3. Instrucciones o sentencias repetitivas o iterativas:

WHILE, DO-WHILE, FOR.

4. Sentencias BREAK y CONTINUE.

INSTRUCCIONES DE CONTROL

1
Introducción a las sentencias de control

2
 INSTRUCCIONES DE CONTROL

Introducción
Hasta ahora solo hemos visto la codificación en el lenguaje C++ de las
estructuras secuenciales, lo que nos proporciona programas lineales, es
decir, comienzan por la primera instrucción y acababan por la última,
ejecutándose todas una sola vez.
Entrada
Secuenciales Salida
Asignación
Estructuras Simples
Condicionales
Algorítmicas Múltiples
Hacer para
Cíclicas Hacer mientras
Repetir hasta

INSTRUCCIONES DE CONTROL

Esta forma de programación sólo me permite resolver problemas

sencillos.

Para resolver problemas más complejos, nos puede interesar que

dependiendo de los valores de los datos, se ejecuten unas instrucciones u
otras. Las instrucciones condicionales nos van a permitir representar
éste tipo de comportamiento.
Sentencias IF y SWITCH

En otro casos, nos encontraremos con la necesidad de repetir una

instrucción ó instrucciones un número determinado de veces. En éstos
casos utilizaremos instrucciones de control iterativas ó repetitivas
(ciclos).

Sentencias WHILE, DO-WHILE y FOR

4
 INSTRUCCIONES DE CONTROL

2
Instrucciones o sentencias condicionales
IF, IF-ELSE, SWITCH

Instrucciones Condicionales

Instrucción condicional simple: IF

Se corresponde con la estructura algorítmica si ? no
condición

El formato general de una Instrucción (es )

sentencia if es la siguiente:

if (condición) if (condición)
{ instrucción;
instrucción 1;
…
instrucción n; Si se cumple la condición, entonces se
} ejecuta la instrucción ó el bloque de
instrucciones; en caso contrario, no se
Atención !!! ejecutan.

6
Instrucciones Condicionales

Instrucción condicional simple: IF

#include <iostream.h>
Ejemplos: int main()
{
...
#include <iostream.h>
int main()
if (cantidad > 100)
{
{
int a, x = 0, y;
descuento = 0.2;
cin >> a;
precio = n*descuento;
}
if (a==0)
x = 1;
...
return 0;
cout << x;
}
return 0;
}

Instrucciones Condicionales

Instrucción condicional doble : IF-ELSE

si ? no
condición
Estructura algorítmica asociada:

Formato general de la Instrucción(es )1 Instrucción(es )2

sentencia if-else

if (condición) if (condición)
{ instrucción 1;
varias instrucciones 1; else
} instrucción 2;
else
{ Si se cumple la condición, se ejecutan las
varias instrucciones 2; instrucciones del primer bloque;
} si no, se ejecutan las instrucciones del segundo
bloque.

8
Instrucciones Condicionales

Instrucción condicional IF, IF-ELSE

Diagrama sintáctico:

if ( condición ) instrucción ;

{ instrucción ; }

else instrucción ;

{ instrucción ; }

Instrucciones Condicionales

Instrucción condicional doble : IF-ELSE

Ejemplos:
#include <iostream.h>
int main()
#include <iostream.h> {
int main() ...
{
int a, x; if (cantidad > 100)
cin >> a; {
descuento = 0.2;
if (a==0) precio = n*descuento;
x = 1; }
else else
x= 0; precio = n;

cout << x; ...

return 0; return 0;
} }

10
Instrucciones Condicionales

Instrucción condicional doble : IF-ELSE anidadas

Hemos visto dos tipos de instrucciones condicionales, con una o dos

alternativas. Podemos utilizar las instrucciones IF-ELSE anidadas, es
decir, que alguna de las ramas sea a su vez otra instrucción IF-ELSE. Así
podemos implementar decisiones que implican más de dos alternativas.

si ? no
condición1
Acción (es) si ? no
condición2
Acción (es) Acción (es)

11

Instrucciones Condicionales

Instrucción condicional doble : IF-ELSE anidadas

La sintaxis de
.
if (condición1) instrucciones IF-ELSE anidadas
instrucción 1;
else
if (condición2) if (condición1)
instrucción 2; instrucción 1;
else else
instrucción 3; if (condición2)
instrucción 2;
else
La escritura en sangría facilita la if (condición3)
comprensión del código así como el instrucción 3;
chequeo del buen funcionamiento. else
instrucción 4;

12
Instrucciones Condicionales

#include <iostream.h> #include <iostream.h>

int main() A int main() B
{ {
int a, b, c, max; int a, b, c, max;
cin >> a >> b >> c; cin >> a >> b >> c;

if (a > b) if (a > b)
if (a > c) if (a > c)
cout << a; ¿Qué hacen cout << a;
else éstos else
cout << c; cout << c;
códigos ?
else else
if (b > c) if (b > c)
cout << b; cout << b;
else else
cout << c; cout << c;
cout << “fin del programa”;
return 0; return 0;
} }

13

Instrucciones Condicionales

Instrucción condicional múltiple : SWITCH

Estructura algorítmica asociada Constante 1 ConstanteN
?
DATO
Formato general de la
sentencia witch Acción (es) Constante 2 Acción (es)

switch (selector) Acción (es) ... ...

{
case constante1:
instrucción1 ó bloque de instrucciones
break;
case constante2: Permiten comparar una
instrucción2 ó bloque de instrucciones
‘variable’ con distintos
break;
defeault: valores posibles, ejecutando
instrucción2 ó bloque de instrucciones para cada caso una serie de
} instrucciones específicas.

14
Instrucciones Condicionales

Instrucción condicional múltiple : SWITCH

Formato general de la
sentencia witch
El valor de selector debe ser un número
switch (selector) entero. Puede ser una variable, una expresión
{ ó una llamada a una función.
case constante1:
instrucción1 ó bloque de instrucciones
break; Cada caso comienza con un
case constante2: case y termina con un break
instrucción2 ó bloque de instrucciones
break;
defeault:
instrucción3 ó bloque de instrucciones ¿Qué ocurre si se me
} olvida algún break ?

15

Instrucciones Condicionales

Instrucción condicional múltiple : SWITCH

#include <iostream.h> Ejemplo

int main ()
{ Si al ejecutar el programa
cin>> num; introducimos un 2, obtenemos
switch (num) el mensaje:
{ ‘Ha introducido el nº 2’
case 1:
cout << “Ha introducido el nº 1\n”;
case 2:
Si al ejecutar el programa
cout << “Ha introducido el nº 2\n”;
break; introducimos un 1, obtenemos
defeault: el mensaje:
cout << “Ha introducido otro nº”; ‘Ha introducido el nº 1’
} ‘Ha introducido el nº 2’
return 0;
}

16
 INSTRUCCIONES DE CONTROL

3
Instrucciones o sentencias repetitivas o iterativas
WHILE, DO-WHILE, FOR

17

Instrucciones Iterativas o repetitivas

Instrucciones de control repetitivas

Son aquellas que controlan la repetición de un conjunto de instrucciones

denominado bloque o cuerpo del bucle, mediante la evaluación de una
condición o mediante un contador.

Sentencias WHILE, DO-WHILE y FOR

18
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : WHILE

Se corresponde con la estructura algorítmica

hacer_mientras: si ? no
condición

Cuerpo del bucle Acción(es)

Formato general de la
sentencia while
Controla la ejecución de un bloque de
instrucciones de tal forma que éstas se ejecutan
while ( condición ) mientras se cumpla la condición, que será
{
instrucción 1;
evaluada siempre antes de cada repetición.
…
instrucción n; Cada repetición del cuerpo
while ( condición )
} instrucción;
del bucle se denomina
iteración

19

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : WHILE

Ejemplo:

#include <iostream.h>
int main()
{
… La condición será evaluada
contador = 0;
while (contador < 100) siempre antes de cada iteración.
{
cuerpo

cout << “Hola”;

El cuerpo del bucle while se repite
contador ++;
} mientras la condición sea cierta.
...
El cuerpo de un bucle while
return 0; se ejecutará cero o más veces.
}

20
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : WHILE

Inicialización La variable que representa la

Se realiza antes de la instrucción while condición del bucle se denomina
variable de control del bucle.
… Dicha variable debe ser:
contador = 0; - inicializada
while (contador < 100)
{
- comprobada
cuerpo - actualizada
cout << “Hola”;
contador ++;
}
...
Comprobación
Se comprueba el valor de la variable
Actualización antes de comenzar la repetición
Se realiza dentro del cuerpo del bucle
durante cada iteración

21

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : WHILE

int main()
{
const bool continuar = true; Inicialización
bool a = true;
int n;
while (a ==continuar) Comprobación
{
cin >> n;
if (n<0) Es importante comprobar que en
{
algún momento, la condición del
cout << "No se admiten negativos";
a = false; bucle se hace falsa, de forma que
} no obtengamos bucles infinitos.
else
cout << "Muy bien, otro más: " ;
}
return 0;
} Actualización

22
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : DO-WHILE

Se corresponde con la estructura algorítmica

Acción(es)

Formato general de la no ?
sentencia do-while condición si
do
instrucción;
do
while ( condición );
{
instrucción 1;
… Se utiliza para ejecutar un bloque de
instrucción n; instrucciones al menos una vez.
El cuerpo del bucle se repite mientras se
} while ( condición );
verifica la condición. Dicha condición será
evaluada después de cada repetición.

23

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : DO-WHILE

Ejemplo:

#include <iostream.h>
int main() El cuerpo de un bucle do-while
{ se ejecutará una o más veces.
char n;
do
{ El cuerpo del bucle do-while
cout << "introducir número: "; se repite mientras la
cuerpo

cin >> n; condición sea cierta.

if ((isdigit(n))== false)
cout << ”Solo se admiten números";

} while ((isdigit(n)) != false);

La condición será evaluada
siempre después de cada
return 0; iteración.
}

24
Instrucciones Iterativas o repetitivas

Diferencias entre las instrucciones

WHILE y DO-WHILE

En while primero se tiene que cumplir

la condición, y luego se ejecuta el si ? no
bloque de instrucciones. condición

Acción(es)

Acción(es)

no ?
En do-while primero se ejecuta el
condición si
bloque de instrucciones y luego se
comprueba la condición.

25

Instrucciones Iterativas o repetitivas

Traducción de WHILE a DO-WHILE

while ( condición )
{ if (condición)
instrucción 1; do
… {
instrucción n; instrucción 1;
} …
instrucción n;
} while ( condición );

26
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR i k inf

Se utiliza para ejecutar un bloque de

si ? no
instrucciones un número fijo de veces que i ≤ sup
se conoce de antemano.
Acción(es)
Se corresponde con la estructura algorítmica
hacer_para: iki+1

for ( inicialización ; condición ; actualización )

{
instrucción 1;
…
instrucción n;
} Formato general de la
sentencia for

27

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

La instrucción for se vale de una variable de control del ciclo. El ciclo se
repite desde el límite inferior, hasta que la variable de control llegue la límite
superior.
for ( inicialización; condición; actualización )
{
instrucción 1; Cabecera del for
…
instrucción n;
}

Una diferencia con el bucle while es que en el for, las operaciones de

control del bucle (inicialización, comprobación y actualización ) se
realizan en un solo sitio: la cabecera del for.

28
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

En la cabecera del for nos podemos encontrar con 3 partes o secciones:

 Parte de inicialización: Inicializa la variable de control del bucle. Se

pueden utilizar una o varias variables.
int main()
 Parte de iteración: Expresión lógica. {
El cuerpo del bucle se repite mientras ….
la expresión sea verdadera. for (int i = 0; i<10; i++)
{
cout << “Número: ” << i ;
 Parte de incremento: Incrementa cout << << endl;
}
o decrementa el valor de la variable ….
o variables de control. return 0;
}

29

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

Ejemplo: La variable de control es n

int main() Es de tipo entero, su valor inicial es 1

{
…. Su valor final es 10
for (int n = 1; n<=10; n=n+2)
{ Se incrementa de 2 en 2.
cout << “Número: ” << n <<“\t” << n*n ;
cout << << endl; Pasada Valor de n
} 1 1
…. 2 3
return 0; 3 5
} 4 7
5 9

En la primera iteración ó pasada, el valor de n es 1, en la segunda pasada

n vale 3. La última pasada se realiza cuando n vale 9.

30
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

Se puede inicializar más de una variable, se puede poner más de una
condición ó más de un incremento.
int main() Se declaran 2 variables de control: i y j
{
….
for ( int i = 0, j = 100; i<j ; i++, j--) Se inicializan a 0 y 100
{ respectivamente
int k;
k = i+2*j ;
cout << k << endl; El cuerpo se ejecutará
} mientras i sea menor que j
….
return 0;
} Se incrementa la variable i y se
decrementa la variable j

31

Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

int main()
Valor de las variables
{ de control en cada pasada
…. valor de i valor de j i+j
for ( int i = 0, j = 5; i+j <100 ; i++, j =j+5 ) 0 5 5
{ 1 10 11
cout << i <<“\t” <<j << (i+j) ; 2 15 17
cout << endl; 3 20 23
4 25 29
}
5 30 35
…. 6 35 41
return 0; 7 40 47
} 8 45 53
Se realizan un total 9 50 59
de 16 pasadas. 10 55 65
11 60 71
12 65 77
Se ejecuta el cuerpo de la instrucción for mientras 13 70 83
14 75 89
se cumpla la condición. 15 80 95

32
Instrucciones Iterativas o repetitivas

Instrucción de control repetitiva : FOR

Se puede omitir cualquiera de las partes de la cabecera del for
(inicialización, condición o incremento).

int main()
{
Se comporta igual que un while
….
contador = 1;
int main()
for ( ; contador <10 ; )
{
{
….
cout << contador ;
for ( ; ; )
contador++ ;
{
}
...
…. Bucle infinito }
return 0;
….
}
return 0;
}

33

INSTRUCCIONES DE CONTROL

4
Sentencias BREAK y CONTINUE

34
Instrucciones Iterativas o repetitivas

Instrucciones break y continue

La instrucción break, además de terminar los case de una instrucción
switch, sirve para forzar la terminación inmediata de un bucle.

{ {
instrucción 1; instrucción 1;
break; continue;
… …
instrucción n; instrucción n;
} }
... ...

La instrucción continue , interrumpe la ejecución del cuerpo del bucle y

fuerza una nueva iteración.

35

Instrucciones Iterativas o repetitivas

Instrucciones break y continue

int main() Ejemplos

{
….
for ( int t = 0; t <100 ; t++ )
{ int main()
cout << t; {
if (t==10) ….
break; // salir del for for ( int t = 0; t <100 ; t++ )
} {
…. if (t%10==0)
return 0; continue;
} cout << t;
}
….
return 0;
}

36
Instrucciones Iterativas o repetitivas

Instrucciones break y continue

Ejemplo
int main()
{
….
do
{ Ignora lo que sigue y vuelve a
cin >> x; comprobar la condición.
if ( x < 0 )
continue;
cout << x;

}while (x !=100);
….
return 0;
}

37