Estructuras de control de flujo iterativas que se añaden a las estructuras de control secuencial y selectiva. Permiten repetir un conjunto de instrucciones un número determinado de veces o hasta que se cumpla una condición.
El primer paso es consultar el estado actual o condición. Aquí se evalúa una expresión lógica que da como resultado un valor booleano. Según el resultado, o bien ejecuta las instrucciones del bucle y vuelve al punto de evaluación de la condición, o bien, se continua con la ejecución del resto del programa, terminan la iteración.
| Consulta sobre el estado actual o condición | `while expresión condicional do` |
| Qué hacer cuando la condición es Cierta | `bloque de instrucciones` |
| Marca de fin de estructura iterativa | `end while` |
#### 9.2.1. Ejemplo Pared
Si la altura de la pared es menor que la altura del techo, se construye una fila de ladrillos y se vuelve a preguntar por la altura de la pared.
```c
algorithm wall
var
heightWall: real;
heightCeiling: real;
end var
heightWall := readReal();
heightCeiling := readReal();
while heightWall <heightCeilingdo
buildWall();
heightWall := readReal();
end while
end algorithm
#include <stdio.h>
int main(int argc, char** argv) {
float heightWall, heightCeiling;
scanf("%f", &heightWall);
scanf("%f", &heightCeiling);
while (heightWall <heightCeiling){
buildWall(); // función que construye una fila de ladrillos y lo suma a la variable heightWall
scanf("%f", &heightWall); // se vuelve a preguntar por la altura de la pared
}
return 0;
}
```
En caso de que la altura de la pared sea mayor o igual a la altura del techo, el bucle no se ejecuta y se continúa con el resto del programa.
#### 9.2.2. Ejemplo Multiplicación
Realizar una multiplicación sin el operador `*`. Podemos hacer la multiplicación de dos números enteros positivos `a` y `b` sumando `a` veces el número `b`.
```c
algorithm multiplicationIntegers
var
n: integer;
m: integer;
x: integer;
end var
n := readInteger();
m := readInteger();
x := 0;
while m ≠ 0 do
x := x+n;
m := m-1;
end while
writeInteger(x);
end algorithm
#include <stdio.h>
int main(int argc, char** argv) {
int n, m, x;
scanf("%d", &n);
scanf("%d", &m);
x = 0;
while (m != 0) {
x = x + n; // Equivalence in C language: x += n;
m = m - 1; // Equivalence in C language: m--;
}
printf("%d", x);
return 0;
}
```
Necesitamos una variable auxiliar `x` que se inicializa a 0. Se suma `n` a `x` tantas veces como `m` sea mayor que 0.
#### 9.2.3. Ejemplo Factorial
Cálculo factorial de un número entero positivo. El factorial de un número se calcula así:
factorial(0) = 1 y
factorial(n) = n * factorial(n-1)
Para hacer el cálculo hay que multiplicar todos los números entre 1 y el número del cual queremos calcular el factorial.
```c
algorithm factorial
var
n: integer;
i: integer;
fact: integer;
end var
n := readInteger();
i := 1:
fact := 1;
while i ≤ n do
fact := fact*i;
i := i+1;
end while
writeInteger(fact);
end algorithm
#include <stdio.h>
int main(int argc, char** argv) {
int n, i, fact;
scanf("%d", &n);
i = 1;
fact = 1;
while ( i <= n ) {
fact = fact*i;
i = i+1;
}
printf("%d", fact);
return 0;
}
```
Cada vez que se ejecuta la iteración, se multiplica el valor de `fact` por el valor de `i` y se incrementa `i` en 1 hasta cumplir con la condición de salida del bucle.
Si la variable `i` no se incrementa en 1, el bucle se ejecutaría indefinidamente.
`while` permite expresar cualquier composición de instrucciones que haya que repetir de acuerdo a unas condiciones determinadas. Es la construcción iterativa más general. Se ejecuta mientras la condición sea verdadera.
| Inicialización de la variable de control<br>e indicación del número de veces<br>que hay que repetir la iteración | `for índice:= valor inicial to valor final do` |
| Qué hacer. | ` bloque de instrucciones` |
| Marca de fin de la estructura iterativa | `end for` |
El C tiene una sintaxis de la composición iterativa for idéntica. Dentro del paréntesis tenemos tres partes separadas por ‘;’ (punto y coma). Cada una de las partes desempeña un papel en la composición.
- *expression1*: es la parte de inicialización. En este primer segmento asignamos el valor inicial a la variable contador (i = 1).
- *expression2*: contiene el test de continuidad. Si la evaluación de la expresión 2 es cierta se pasará a ejecutar el cuerpo del bucle. Si resulta falsa se continuará la ejecución con la instrucción inmediatamente posterior al cuerpo de la composición.
- *expression3*: es la parte de actualización del contador. La expression3 se evaluará cuando se acabe de ejecutar el cuerpo del bucle y antes de pasar a evaluar el test. En esta parte se encuentra la instrucción que modifica la variable contador (i++).
La forma que hemos visto de la composición iterativa for (que en cada vuelta se incrementa el contador en una unidad) es la más habitual. Pero no responde a todos los planteamientos con los que nos podemos encontrar.
1. Queremos simular una cuenta atrás desde un valor determinado hasta 0.
2. Queremos hacer la suma de todos los números pares entre dos números entrados.
La composición for dispone de variantes que facilitan este trabajo de indicar cómo queremos que varíe el contador en cada iteración. A la sintaxis se añade la indicación de step . Por defecto, si no se indica, ya hemos visto que se asume que step es igual a 1:
```c
for índice:= valor inicial to valor final [step valor de incremento/decremento] do
i = 0; // the base index of array is 0 in C language
sum = 0.0;
while (i <7){//"<="ischangedby"<"becauseinClanguagelastelementofaN-sizearrayisN-1
scanf("%f", &dailyTemp[i]);
sum = sum + dailyTemp[i];
i = i+1;
}
printf("%f", sum/7);
return 0;
}
```
Para la temperatura de todo el año será prácticamente igual:
```c
algorithm meanTemp
var
dailyTemp: vector[365] of real;
sum: real;
i: integer;
end var
i := 1;
sum := 0.0;
while i ≤ 365 do
dailyTemp[i] := readReal();
sum := m + dailyTemp[i];
i := i+1;
end while
writeReal(sum/365.0);
end algorithm
#include <stdio.h>
int main(int argc, char** argv) {
float dailyTemp[365];
float sum;
int i;
i = 0;
sum = 0.0;
while (i <365){
scanf("%f", &dailyTemp[i]);
sum = sum + dailyTemp[i];
i = i+1;
}
printf("%f", sum/365.0);
return 0;
}
```
Una mejor opción sería utilizar la estructura `for`, aprovechando que sabemos cuántos elementos del vector es necesario recorrer.
```c
const
DAYS: integer = 365;
end const
algorithm meanTemp
var
dailyTemp: vector[DAYS] of real;
sum: real;
i: integer;
end var
sum:=0.0;
for i:=1 to DAYS do
dailyTemp[i] := readReal();
sum := sum + dailyTemp[i];
end for
writeReal(sum/integerToReal(DAYS));
end algorithm
#include <stdio.h>
#define DAYS 365
int main(int argc, char** argv) {
float dailyTemp[DAYS];
float sum;
int i;
sum = 0.0;
for (i = 0; i <DAYS;i++){
scanf("%f", &dailyTemp[i]);
sum = sum + dailyTemp[i];
}
printf("%f", sum/DAYS);
return 0;
}
```
- **Ha helado**: Disponemos de un registro de las temperaturas de todo el año, que tenemos almacenadas en un vector, de la misma manera que hemos hecho en el ejemplo anterior. Ahora queremos descubrir si algún día ha helado. Esto equivale a ir comprobando si alguna de les temperaturas es negativa.
```c
algorithm frozenDays
var
dailyTemp: vector[365] of real;
hasFrozen: boolean;
i: integer;
end var
i := 1;
hasFrozen := false;
while i ≤ 365 and hasFrozen = false do
dailyTemp[i] := readReal();
if dailyTemp[i] ≤ 0 then
hasFrozen := true;
end if
i := i+1:
end while
writeBoolean(hasFrozen);
end algorithm
#include <stdio.h>
#include <stdbool.h>
int main(int argc, char** argv) {
float dailyTemp[365];
bool hasFrozen;
int i;
i = 0;
hasFrozen = false;
while (i <365&&!hasFrozen){
scanf("%f", &dailyTemp[i]);
if (dailyTemp[i] <= 0) {
hasFrozen = true;
}
i = i+1;
}
printf("%d", hasFrozen); /* Equivalence in C language: 0 == false, 1 == true */
return 0;
}
```
- **Cuenta de días**
Si quisiéramos saber cuántos días ha helado, entonces tendríamos que revisar todos los elementos del vector y en este caso sería más adecuada una estructura `for`.
**Negrita** se utiliza para las palabras clave del lenguaje.
*Cursiva* se tiene que sustituir por el identificador definido por el usuario (nombre de la variable, del tipo, etc.); no significa que los identificadores vayan en cursiva en los algoritmos.
Castellano se utiliza para describir instrucciones.
### 10.1 Tipos básicos
```
integer
char
real
boolean
string
```
### 10.2 Declaración de constantes
```
const
CONST_NAME: type = valor;
end const
```
### 10.3 Declaración de tuplas
```
type
typeName = record
fieldName: tipo del campo;
end record
end type
```
### 10.4 Condicional
```
if expresión condicional then
bloque de instrucciones
end if
---
if expresión condicional then
bloque de instrucciones
else
bloque de instrucciones
end if
```
### 10.5 Declaración de tipos
```
type
typeName = declaración del tipo
end type
```
### 10.6 Declaración de variables
```
var
varName: tipo de la variable;
end var
```
### 10.7 Declaración de vectores
```
var
vectorName: vector[longitud] of tipo del campo;
end var
```
### 10.8 Iteración
```
while expresión condicional do
bloque de instrucciones
end while
---
for varName := valor inicial to valor final [step valor de incremento/decremento] do
bloque de instrucciones
end for
```
### 10.9 Clase de parámetros
```
in
out
inout
```
### 10.10 Declaración de algoritmo
```
algorithm
bloque de instrucciones
end algorithm
```
### 10.11 Declaración de punteros
```
var
varName: pointer to tipo del campo
end var
```
### 10.12 Operadores lógicos
```
and
or
not
```
### 10.13 Operador de asignación
```
:=
```
### 10.14 Operadores de comparación
```
=
≠
<
>
≤
≥
```
### 10.15 Constantes booleanas
```
true
false
```
### 10.16 Comentario
```
{ comentario }
```
### 10.17 Función
```
function functionName (parName1: tipo del parámetro, ... , parNameN: tipo del parámetro): tipo del retorno
bloque de instrucciones
end function
```
### 10.18 Acción
```
action actionName (clase del parámetro parName1: tipo del parámetro, ... , clase del parámetro parNameN: tipo del parámetro)
