Sentencias Control

Sentencias de control
Tabla de contenido
1. Sentencias de control .............................................................................................................................................. 2
1.1 Expresiones lógicas ............................................................................................................................................ 2
1.1.1 Comparar tipos de datos ............................................................................................................................ 2
1.1.2 Operadores lógicos ..................................................................................................................................... 6
1.2 Sentencia if/else .......................................................................................................................................... 7
1.2.1 Ejercicio de decisiones .............................................................................................................................. 10
1.3 Sentencia switch case .............................................................................................................................. 20
1.4 Ciclos ............................................................................................................................................................... 29
1.4.1 Sentencia while ..................................................................................................................................... 29
1.4.2 Sentencia do-while ................................................................................................................................ 32
1.4.3 Ciclo for .................................................................................................................................................. 36
1.4.4 Ciclos anidados ......................................................................................................................................... 45
1.5 Sentencia break ............................................................................................................................................ 49
1.6 Sentencia continue ..................................................................................................................................... 51
Perspectiva ............................................................................................................................................................ 53
Resumen................................................................................................................................................................ 53
1
1. Sentencias de control
En este capítulo se codificarán más sentencias de decisión y de control.
1.1 Expresiones lógicas

Estas expresiones se evalúan y dan como resultado 1 ó 0.
1.1.1 Comparar tipos de datos
Operadores relacionales
Operador Nombre Descripción
== Igualdad Regresa un valor 1 si ambos operadores son iguales.
!= Desigualdad Regresa un valor 1 si ambos operadores no son iguales.
> Mayor que Regresa un valor 1 si el operador de la izquierda es mayor que el operador
de la derecha.
< Menor que Regresa un valor 1 si el operador de la izquierda es menor que el operador
de la derecha.
≥ Mayor o igual que Regresa un valor 1 si el operador de la izquierda es mayor o igual que el
operador de la derecha.
≤ Menor o igual que Regresa un valor 1 si el operador de la izquierda es menor o igual que el
operador de la derecha.
Ejemplos de expresiones lógicas

/* Igualdad en una expresión numérica
* ¿el contenido de descuentoPorcentaje es igual a 4.8? */
double descuentoPorcentaje = 4.79;
printf("\n\n%d", descuentoPorcentaje == 4.8);
/* Igualdad con un caracter

* ¿el contenido de letra es igual a y? */
char letra = 'Y';
printf("\n\n%d", letra == 'y');
/* Igualdad con el valor 0

* ¿el contenido de esValido igual a 0? */
int esValido = 0;
printf("\n\n%d", esValido == 0);
/*Desigualdad en una expresión numérica

* ¿el contenido de subtotal no es igual a 0.0? */
double subTotal = 0.0;
printf("\n\n%d", subTotal != 0.0);
2
/* Mayor que en una expresión numérica

* ¿el contenido de anios es mayor que 0? */
int anios = -1;
printf("\n\n%d", anios > 0);
/*Menor que con una variable

* ¿el contenido de i es menor que meses? */
int i = 7;
double meses = 7.1;
printf("\n\n%d", i < meses);
/* Mayor o igual que en una expresión numérica

* ¿el contenido de subTotal es mayor o igual que 1000? */
printf("\n\n%d", subTotal >= 1000);
/* Menor o igual que con una variable

* ¿el contenido de cantidad es menor o igual que pedido? */
double cantidad = 2013.999;
double pedido = 2014;
printf("\n\n%d", cantidad <= pedido);
3
Codificación de los ejemplos anteriores:

/* comparaciones-logicas-c */
#include <stdio.h>
#include <math.h>
int main(){
/* Igualdad en una expresión numérica

* ¿el contenido de descuentoPorcentaje es igual a 4.8? */
printf("\n\nIgualdad en una expresion numerica");
printf("\nEl contenido de descuentoPorcentaje es igual a 4.8?");
printf("\ndescuentoPorcentaje = 4.79");
printf("\ndescuentoPorcentaje == 4.8?");
double descuentoPorcentaje = 4.79;
printf("\n%d", descuentoPorcentaje == 4.8);
/* Igualdad con un caracter

* ¿el contenido de letra es igual a y? */
printf("\n\nIgualdad con un caracter");
printf("\nEl contenido de letra es igual a y?");
printf("\nletra = 'Y'");
printf("\nletra == 'y'?");
char letra = 'Y';
printf("\n%d", letra == 'y');
/* Igualdad con el valor 0

* ¿el contenido de esValido igual a 0? */
printf("\n\nIgualdad con el valor 0");
printf("\nEl contenido de esValido igual a 0?");
printf("\nesValido = 0");
printf("\nesValido == 0?");
int esValido = 0;
printf("\n%d", esValido == 0);
/* Desigualdad en una expresión numérica

* ¿el contenido de subtotal no es igual a 0.0? */
printf("\n\nDesigualdad en una expresion numérica");
printf("\nEl contenido de subtotal no es igual a 0.0?");
printf("\nsubTotal = 0.0");
printf("\nsubTotal != 0.0?");
double subTotal = 0.0;
printf("\n%d", subTotal != 0.0);
/* Mayor que en una expresión numérica

* ¿el contenido de anios es mayor que 0? */
printf("\n\nMayor que en una expresion numerica");
printf("\nEl contenido de anios es mayor que 0?");
printf("\nanios = -1");
printf("\nanios > 0?");
int anios = -1;
printf("\n%d", anios > 0);
/* Menor que con una variable

* ¿el contenido de i es menor que meses? */
printf("\n\nMenor que con una variable");
printf("\nEl contenido de i es menor que meses?");
printf("\ni = 7");
printf("\nmeses = 7.1");
printf("\ni < meses?");
int i = 7;
double meses = 7.1;
printf("\n%d", i < meses);
4
/* Mayor o igual que en una expresión numérica

* ¿el contenido de subTotal es mayor o igual que 1000? */
printf("\n\nMayor o igual que en una expresion numerica");
printf("\nEl contenido de subTotal es mayor o igual que 1000?");
printf("\nsubTotal >= 1000?");
printf("\n%d", subTotal >= 1000);
/* Menor o igual que con una variable

* ¿el contenido de cantidad es menor o igual que pedido? */
printf("\n\nMenor o igual que con una variable");
printf("\nEl contenido de cantidad es menor o igual que pedido?");
printf("\ncantidad = 2013.999");
printf("\npedido = 2014");
printf("\ncantidad <= pedido?");
double cantidad = 2013.999;
double pedido = 2014;
printf("\n%d", cantidad <= pedido);
return 0;
}
Descripción
• Se usan los operadores relacionales para crear expresiones booleanas que comparen dos operadores y
regresen un valor booleano 1 ó 0.
• Si se comparan dos operadores numéricos que no son del mismo tipo, C convertirá el operador de menor
precisión a un tipo de mayor precisión antes de hacer la comparación. Por ejemplo, si se compara un tipo
int con un tipo double, el tipo int se convertirá al tipo double antes de realizar la comparación.
5
1.1.2 Operadores lógicos

Operador Nombre Descripción
&& AND Regresa el valor 1 si ambas expresiones son verdaderas. Este operador sólo evalúa
la segunda expresión si es necesario
|| OR Regresa el valor 1e si alguna expresión es verdadera. Este operador sólo evalúa la
segunda expresión si es necesario
& AND Regresa el valor 1 si ambas expresiones son verdaderas. Este operador siempre
evalúa ambas expresiones.
| OR Regresa el valor 1 si alguna de las expresiones es verdadera. Este operador
siempre evalúa ambas expresiones.
! NOT Invierte el valor de la expresión.
Ejemplos
subTotal >= 250 && subtotal < 500
tiempo <=4 || tiempo >=12
esValido == 1 & contador++ < meses

esValido == 1 | contador++ < meses
(subTotal >= 250 && subTotal < 500) || esValido == 1
!(contador++ >=meses)
Descripción
• Se utilizan los operadores lógicos para crear una expresión booleana que combine dos o más expresiones
lógicas.
• Los operadores && y || solamente evalúan la segunda expresión en caso de ser necesario, por lo que se les
suele llamar operadores de corto circuito y son más eficientes que los operadores & y |.
• Por definición, las operaciones NOT se ejecutan primero, seguido de las operaciones AND y por último, siguen
las operaciones OR. Estas operaciones se ejecutan después de las operaciones aritméticas y relacionales.
• Si es necesario, se puede usar el operador ! para invertir el valor de una expresión. Por ejemplo, en lugar de
codificar:
!(subtotal < 100)
se puede codificar:
subtotal >= 100
Ambas expresiones ejecutan la misma tarea, pero la segunda expresión es más fácil de leer.
• Se pueden usar paréntesis para cambiar la secuencia en que se ejecutan las operaciones o bien, para clarificar
la secuencia de operaciones.
6
1.2 Sentencia if/else

Sintaxis de la sentencia if/else
if (expresionBooleana) {sentencias}
[else if (expresionBooleana) {sentencias}]…
[else {sentencias}]
Diagrama de flujo
7
Cada vez que se codifica un par de llaves en C, explícitamente se está definiendo un bloque de código que
puede contener una o más sentencias. Cualquier variable que se declare dentro de las llaves tiene un ámbito
de bloque, es decir, no pueden accederse fuera de ese bloque. Como resultado, si se desea acceder la variable
fuera del bloque, debe declararse antes del bloque. Esto se muestra en el siguiente ejemplo:
8
Ejemplo 1: una sentencia if que contiene dos bloques de código

char tipoEmbarque = ' ';
double porcentajeDescuento = 0.0;
if (tipoEmbarque == 'R'){
porcentajeDescuento = 0.1;
metodoEmbarque = "UPS";
}
else{
if (tipo Cliente == 'C'){
metodoEmbarque = "Bulto";
}
else
metodoEmbarque = "USPS";
}
Las sentencias dentro de un bloque if/else tienen un ámbito de bloque aún cuando no se codifiquen las llaves.
Como resultado, si se desea acceder a una variable que está dentro de un bloque if/else, se debe declarar
antes de la cláusula if/else, como se muestra en el siguiente ejemplo:
Ejemplo 2: una sentencia if con cláusulas else if y else

if (subTotal > 0.0 && subTotal < 200.0)
porcenajeDescuento = 0.1;
else if (subTotal >= 200.0 && subtotal < 300.0)
else if (subTotal >= 300.0)
else
Ejemplo 3: sentencias if anidadas

if tipoCliente = 'M'){
if (subTotal >= 100)
else
}
else
9
1.2.1 Ejercicio de decisiones

Una empresa abarrotera vende sus productos a tres tipos de clientes y les ofrece descuentos según la venta que
se haya realizado al cliente. A los clientes que son mayoristas, no les ofrece descuento si la venta es inferior a
$1,000; si la venta es desde $1,000 y menor que $25,000, les otorga el 30% de descuento; a partir de $25,000, les
otorga el 40% de descuento.
A los clientes que acuden a su tienda, si la venta es menor a $3,000, les otorga el 10% de descuento; a partir de
$3,000, les otorga el 20% de descuento.
A otro tipo de clientes siempre les otorga el 10% de descuento sobre la venta.
Determinar el porcentaje de descuento para cada tipo de clientes. Así mismo, determinar el descuento en pesos,
el sub total, el IVA y el total a pagar.
Ejemplo:
Empresa Abarrotera “La surtidora”
Tipo de cliente:
M)ayorista
T)ienda
O)tro
Ingresar el tipo de cliente: M

Venta: 25000
********************************************
Resumen:
Venta: 25000
Porcentaje de descuento: 40%
Descuento: 10000
--------------------------------------------
Sub total: 15000
IVA 16%: 2400
--------------------------------------------
Total a pagar: 17400
********************************************
Elaborar el diagrama de entrada/salida, la tabla de decisiones, el árbol de decisiones, el diagrama de flujo, el pseudocódigo y
la codificación en lenguaje C.
10
1.2.1.1. Diagrama de entrada/salida
1.2.1.2Tabla de decisiones
Cliente venta porcentajeDescuento
≥0 y < 1,000 0
M ≥ 1,000 y < 25,000 0.3
≥ 25,000 0.4
≥0 y < 3,000 0.1
T
≥ 3,000 0.2
O ----------------------------- 0.1
11
1.2.1.3 Árbol de decisiones
12
13
1.2.1.4 Diagrama de flujo
14
15
1.2.1.5 Pseudocódigo
/* la-surtidora-pseudo.c
* Pseudocódigo*/
Inicio
opcion <- 's'
cliente =<- ' '
venta <- 0, porcentajeDescuento <- 0, descuento <- 0, subtotal<- 0
iva <- 0, total <- 0
Mientras (opcion = 's' OR opcion = 'S') Hacer
Imprimir "Empresa Abarrotera 'La Surtidora'"
Imprimir "Tipo de cliente"
Imprimir "M)ayorista"
Imprimir "T)ienda"
Imprimir "O)tro"
Imprimir "Ingresar el tipo de cliente:"
Leer cliente
Imprimir "Venta:"
Leer venta
Si (cliente = 'M')
Si (venta >= 0 AND venta < 1000)
porcentajeDescuento <- 0
Sino
porcentajeDescuento <- 0.3
Sino
Fin Si
Fin Si
Sino
Si (cliente = 'T')
Sino
porcentajeDescuento =<-0.2
Fin Si
Sino
Fin Si
Fin Si
16
// Cálculos
descuento <- venta * porcentajeDescuento
subTotal <- venta - descuento
iva <- subTotal * 0.16
total <- subTotal + iva
// Impresión de datos
Imprimir "Venta: " venta
Imprimir "Porcentaje de descuento: " porcentajeDescuento
Imprimir "Descuento : " descuento
Imprimir "Sub total: " subTotal
Imprimir "16% iva: " iva
Imprimir "Total a pagar: " total
Imprimir "Desea volver a ejecutar el programa (S/N)?: "

Leer opcion
Fin mientras
Fin
17
1.2.1.6 Codificación
/* la-surtidora.c */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(){
char opcion = 's';
char cliente = ' ';
double venta = 0.0;
double porcentajeDescuento = 0.0, descuento = 0.0, subTotal = 0.0, iva = 0.0, total = 0.0;
while (opcion == 's' || opcion == 'S'){

printf("\n\n\n\tEmpresa Abarrotera 'La Surtdora'");
printf("\n====================================================");
printf("\n\n\tTipo de cliente:");
printf("\n\tM)ayorista");
printf("\n\tT)ienda");
printf("\n\tO)tro");
// Captura de datos
printf("\n\nIngresar el tipo de clliente: ");
scanf("%c", &cliente);fflush(stdin);
printf("\nVenta: ");
scanf("%lf", &venta);fflush(stdin);
// Decisiones
if (cliente == 'M'){
if (venta >= 0.0 && venta < 1000.0){
}
else{
if (venta >= 1000.0 && venta < 25000.0){
}
else{
}
}
}
else{
if (cliente == 'T'){
if (venta >= 0.0 && venta < 3000.0){
}
else{
}
}
else{
}
}
18
// Cálculos
descuento = venta * porcentajeDescuento;
subTotal = venta - descuento;
iva = subTotal * 0.16;
total = subTotal + iva;
// Impresión de datos
printf("\n\n****************************************************");
printf("\nResumen:");
printf("\n\nVenta: \t\t\t\t%.0lf", venta);
printf("\nPorcentaje de descuento: \t%.0lf %%", porcentajeDescuento * 100);
printf("\nDescuento: \t\t\t%.0lf", descuento);
printf("\n----------------------------------------------------");
printf("\nSub-Total: \t\t\t%.0lf", subTotal);
printf("\nIva 16%: \t\t\t%.0lf", iva);
printf("\nTotal a pagar: \t\t\t%.0lf", total);
printf("\n\n****************************************************");
printf("\n\nDesea volver a ejecutar el programa (S/N)?: ");

scanf("%c", &opcion);fflush(stdin);
}
return 0;
}
Descripción
• Si una cláusula if/else contiene sólo una sentencia, no se necesita encerrarla entre llaves y deberá
concluir con punto y coma. Sin embargo, si se escribe sólo una sentencia en una cláusula if/else, la
sentencia no deberá ser la declaración de una variable, pues en cuyo caso, el compilador mandará un
mensaje de error.
• Si una cláusula if/else requiere más de una sentencia, se debe encerrar el bloque de sentencias en llaves.
Cualquier variable que se declare dentro de un bloque, tiene un ámbito de bloque, por lo que solamente se
podrá usar dentro del bloque.
• Cuando se declara una variable dentro de una cláusula if/else, la variable debe estar encerrada por llaves.
• Cuando se aniden cláusulas if/else, es una buena práctica indentarlas o tabularlas, al igual que su
contenido, ya que permite una mejor lectura del programa.
• Otra buena práctica es codificar las condiciones con una estructura lógica y en una secuencia lógica.
• Si es necesario, se pueden agregar comentarios al código para una mejor lectura. Entre más fácil sea de leer y
entender un código, más fácil será probarlo, depurarlo y darle mantenimiento.
19
1.3 Sentencia switch case

Sintaxis de la sentencia switch
switch (expresionInteger){
case etiqueta1:
sentencias:
break;
case etiqueta2:
sentencias:
break;
case etiqueta3:
sentencias:
break;
cualquier otras sentencias case
default: (opcional)
sentencias;
break;
}
Diagrama de flujo
20
Ejemplo 1:
Algoritmo que imprime el día de la semana, según la siguiente tabla:
No. Día de la semana
--------------------------------
1 Domingo
2 Lunes
3 Martes
4 Miércoles
5 Jueves
6 Viernes
7 Sábado
21
/* dias-semana-pseudo.c
* Pseudocódigo */
Inicio
n <- 0
Imprimir "Programa que utiliza la estructura switch-case"
Imprimir "Días de la semana"
Imprimir "Ingresar un número en el rango 1 - 7: "
Leer n
Según sea n
caso 1:
Imprimir "Domingo"
caso 2:
Imprimir "Lunes"
caso 3:
Imprimir "Martes"
caso 4:
Imprimir "Miércoles"
caso 5:
Imprimir "Jueves"
caso 6:
Imprimir "Viernes"
caso 7:
Imprimir "Sábado"
Otros:
Imprimir "Error: número fuera de rango."
Fin según sea
Fin
22
*/* Nombre del programa: dias-semana.c */

#include <stdio.h>
#include <conio.h>
int main(){
int n = 0;
printf("\nPrograma que utiliza la estructura switch - case");
printf("\nDias de la semana");
printf("\n=================================================");
printf("\n\n\nIngresar un numero en el rango 1 - 7: ");
scanf("%d",&n);fflush(stdin);
switch (n){
case 1:
printf("\nDomingo");
printf("\n\nPresione una tecla para continuar...");
getch();
break;
case 2:
printf("\nLunes");
getch();
break;
case 3:
printf("\nMartes");
getch();
break;
case 4:
printf("\nMiercoles");
getch();
break;
case 5:
printf("\nJueves");
getch();
break;
case 6:
printf("\nViernes");
getch();
break;
case 7:
printf("\nSabado");
getch();
break;
default:
printf("\nError: numero fuera de rango.");
getch();
break;
}
return 0;
}
23
dias-semana
Prueba de escritorio días de la semana
n == 1 n == 2 n == 3 n == 4 n == 5 n == 6 n == 7 Otros
Número de Imprimir "Error: número
renglón n Leer n Imprimir "Domingo" Imprimir "Lunes" Imprimir "Martes" Imprimir "Miércoles" Imprimir "Jueves" Imprimir "Viernes" Imprimir "Sábado" fuera de rango"
1 0 1 ✓ ------- ------- ------- ------- ------- ------- -------
Si se vuelve a ejecutar el programa:

n == 1 n == 2 n == 3 n == 4 n == 5 n == 6 n == 7 Otros
1 0 3 ------- ------- ✓ ------- ------- ------- ------- -------

n == 1 n == 2 n == 3 n == 4 n == 5 n == 6 n == 7 Otros
1 0 9 ------- ------- ------- ------- ------- ------- ------- ✓
24
Ejemplo 2:
Algoritmo que imprime la estación del año, según la siguiente tabla:
Letra Estaciones del año
-------------------------------------
a Primavera
b Verano
c Otoño
d Invierno
25
/* estaciones-anio-pseudo.c
* Pseudocódigo */
Inicio
e <-- ' '
Imprimir "Programa que utiliza la estructura switch-case"
Imprimir "Estaciones del año"
Imprimir "Ingresar una estación del año en el rango a - d: "
Leer e
Según sea e
caso 'a':
Imprimir "Primavera"
caso 'b':
Imprimir "Verano"
caso 'c':
Imprimir "Otoño"
caso 'd':
Imprimir "Invierno"
Otros:
Imprimir "Error: letra fuera de rango."
Fin según sea
Fin
26
/* Lenguaje de programación C
* Programa que utiliza la estructura switch - case,
* tomando como base las estaciones del año.
* Programador:
* Fecha:
* Nombre del programa: estaciones-anio.c */
#include <stdio.h>
#include <conio.h>
int main(){
char e = ' ';
printf("\nPrograma que utiliza la estructura switch - case");
printf("\ntomando como ejemplo, las estaciones del año");
printf("\n=================================================");
printf("\n\n\nIngresar la estacion del anio en el rango (a - d): ");
scanf("%c",&e);fflush(stdin);
switch (e){
case 'a':
printf("\nPrimavera");
getch();
break;
case 'b':
printf("\nVerano");
getch();
break;
case 'c':
printf("\nOtoño");
getch();
break;
case 'd':
printf("\nInvierno");
getch();
break;
default:
printf("\nError: letra fuera de rango.");
getch();
break;
}
return 0;
}
27
estaciones-anio
Prueba de escritorio de las estaciones del año
e == 'a' e == 'b' e == 'c' e == 'd' Otros

Número de Imprimir Imprimir Imprimir "Error: letra
renglón e Leer e "Primavera" "Verano" Imprimir "Otoño" Imprimir "Invierno" fuera de rango"
1 '' a ✓ ------- ------- ------- -------

e == 'a' e == 'b' e == 'c' e == 'd' Otros
1 '' d ------- ------- ------- ✓ -------

e == 'a' e == 'b' e == 'c' e == 'd' Otros
1 '' w ------- ------- ------- ------- ✓
Descripción
• La sentencia switch solamente se utiliza con una expresión que evalúa uno de estos tipos: char,o int. Las
etiquetas case representan los valores enteros de la expresión.
• La sentencia switch transfiere el control a la etiqueta apropiada. Si el control no se transfiere a una de las
etiquetas case, se ejecuta la etiqueta opcional default.
• Si una etiqueta no contiene la sentencia break, la ejecución del código seguirá en la siguiente etiqueta. De lo
contrario, la sentencia break concluye la sentencia switch.
28
1.4 Ciclos
1.4.1 Sentencia while
Sintaxis del ciclo while

while (expresionBooleana){
sentencias
}
Diagrama de flujo del ciclo while
29
Ejemplo: Un ciclo while que calcula la sumatoria del 1 al 10
/* sumatoria10While-pseudo.c
* Pseudocódigo */
Inicio
i <-- 0
suma <-- 0
Mientras (i <= 10) Hacer

suma <-- suma + i
Imprimir i, suma
i <-- i + 1
Fin mientras
Imprimir "La suma del 1 al 10 es: " suma
Fin
30
/* sumatoria10While.c */
#include <stdio.h>
#include <math.h>
int main(){
int i = 0;
int suma = 0;
printf("\nPrograma que suma del 1 al 10 mediante el ciclo while");

printf("\n-------------------------------------------------------");
printf("\n\n\ti\tsuma");
printf("\n---------------------");
while (i <= 10){

suma = suma + i; // suma += i;
printf("\nDebug: %d\t%d", i, suma);
++i;
}
printf("\nLa suma del 1 al 10 es: %d", suma);

return 0;
}
Sumatoria del 1 al 10 mediante un ciclo while

Prueba de escritorio
VERDAD FALSO
Imprimir
Número de
renglón i suma i ≤ 10 Resp. suma = suma + i i suma i = i + 1 Imprimir suma
1 0 0 0 ≤ 10 V 0 0 0 1 --------
2 1 0 1 ≤ 10 V 1 1 1 2 --------
3 2 1 2 ≤ 10 V 3 2 3 3 --------
4 3 3 3 ≤ 10 V 6 3 6 4 --------
5 4 6 4 ≤ 10 V 10 4 10 5 --------
6 5 10 5 ≤ 10 V 15 5 15 6 --------
7 6 15 6 ≤ 10 V 21 6 21 7 --------
8 7 21 7 ≤ 10 V 28 7 28 8 --------
9 8 28 8 ≤ 10 V 36 8 36 9 --------
10 9 36 9 ≤ 10 V 45 9 45 10 --------
11 10 45 10 ≤ 10 V 55 10 55 11 --------
12 11 55 11 ≤ 10 F -------- -------- -------- -------- 55
31
1.4.2 Sentencia do-while
Sintaxis del ciclo do-while

do{
sentencias
} while (expresionBooleana
Diagrama de flujo del ciclo do-while
32
Ejemplo: Un ciclo do-while que calcula la sumatoria del 1 al 10
/* sumatoria10DoWhile-pseudo.c
* Pseudocódigo */
Inicio
i <-- 0
suma <-- 0
Hacer
suma <-- suma + i
Imprimir i, suma
i <-- i + 1
Mientras (i <= 10)
Fin
33
/* sumatoria10DoWhile.c */
#include <stdio.h>
#include <math.h>
int main(){
int i = 0;
int suma = 0;
printf("\nPrograma que suma del 1 al 10 mediante el ciclo do - while");

printf("\n----------------------------------------------------------");
printf("\n---------------------");
do{
suma += i; // suma = suma + i;
++i;
} while (i <= 10);

return 0;
}
Sumatoria del 1 al 10 mediante un ciclo do - while

VERDAD FALSO
Imprimir
Número de
renglón i suma suma = suma + i i suma i = i + 1 i ≤ 10 Resp. Imprimir suma
1 0 0 0 0 0 1 1 ≤ 10 V --------
2 1 0 1 1 1 2 2 ≤ 10 V --------
3 2 1 3 2 3 3 3 ≤ 10 V --------
4 3 3 6 3 6 4 4 ≤ 10 V --------
5 4 6 10 4 10 5 5 ≤ 10 V --------
6 5 10 15 5 15 6 6 ≤ 10 V --------
7 6 15 21 6 21 7 7 ≤ 10 V --------
8 7 21 28 7 28 8 8 ≤ 10 V --------
9 8 28 36 8 36 9 9 ≤ 10 V --------
10 9 36 45 9 45 10 10 ≤ 10 V --------
11 10 45 55 10 55 11 11 ≤ 10 F 55
34
Descripción
• En un ciclo while, la condición se revisa antes de que se ejecute el ciclo. En un ciclo do-while, la
condición se revisa después de que se ejecuta el ciclo.
• Un ciclo while o do-while ejecuta un bloque de sentencias mientras sea verdadera la condición o
expresión booleana. El bloque de sentencias deja de ejecutarse cuando la condición o expresión booleana es
falsa.
• Si un ciclo requiere más de una sentencia, éstas deben encerrarse en llaves. Las llaves identifican un bloque
de sentencias; las sentencias las ejecuta el ciclo while o do-while. Las variables o constantes que se
declaren dentro de las llaves, tienen un ámbito de bloque, por lo que estas variables o constantes sólo
existirán dentro de las llaves. Cuando el flujo del programa salga del ciclo, dichas variables y constantes ya
no existirán, pues se declararon dentro de las llaves. Por lo tanto, las variables o constantes que se
declaren dentro de un ciclo, no podrán usarse fuera del ciclo.
• Las variables o constantes que se necesiten usar fuera del ciclo, deben declararse antes del ciclo, de tal
forma que esas variables o constantes que pasan dentro del ciclo y en el caso de las variables, que modifican
sus valores, pueden usarse después del ciclo.
• Si un ciclo tiene dentro una sentencia, no es necesario escribir las llaves. Sin embargo, si esa única sentencia
es la declaración de una variable o constante, C mandará un mensaje de error, ya que esa única sentencia, no
deberá ser la declaración de una variable o constante. En tal caso, si se desea declarar una variable o
constante dentro del ciclo, se deberá escribir entre llaves, para que el compilador no mande un mensaje de
error.
• Si la condición lógica de la sentencia while nunca llega a ser falsa, el ciclo nunca finalizará y entrará en un
ciclo infinito. Para cancelar un ciclo infinito, se debe oprimir Ctrl+C. Un ciclo infinito no debería presentarse.
Si se presenta un ciclo infinito, se dice que hay un error en la lógica del programa, el cual debe analizarse y
corregirse.
35
1.4.3 Ciclo for

Sintaxis del ciclo for
for(expresionInicalizacion; expresionBooleana; expresionIncrementoDecremento){
sentencias
}
Diagrama de flujo
36
37
Ejemplo 1: un ciclo for que calcula la sumatoria del 1 al 10
/* sumatoria10For-pseudo.c
* Pseudocódigo */
Inicio
i
suma <-- 0
Desde i <-- 0 Hasta i <= 10 Incrementar i en 1

suma <-- suma + i
Imprimir i, suma
Fin desde
Fin
38
/* sumatoria10For.c */
#include <stdio.h>
#include <math.h>
int main(){
int i;
int suma = 0;
printf("\nPrograma que suma del 1 al 10 mediante el ciclo for");

printf("\n-----------------------------------------------------");
printf("\n---------------------");
for(i = 0; i <= 10; ++i){

suma += i; // suma = suma + i;
}

return 0;
}
Sumatoria del 1 al 10 mediante un ciclo for

VERDAD FALSO
Imprimir
Número de
renglón i suma i ≤ 10 Resp. suma = suma + i i suma i = i + 1 Imprimir suma
1 0 0 0 ≤ 10 V 0 0 0 1 --------
2 1 0 1 ≤ 10 V 1 1 1 2 --------
3 2 1 2 ≤ 10 V 3 2 3 3 --------
4 3 3 3 ≤ 10 V 6 3 6 4 --------
5 4 6 4 ≤ 10 V 10 4 10 5 --------
6 5 10 5 ≤ 10 V 15 5 15 6 --------
7 6 15 6 ≤ 10 V 21 6 21 7 --------
8 7 21 7 ≤ 10 V 28 7 28 8 --------
9 8 28 8 ≤ 10 V 36 8 36 9 --------
10 9 36 9 ≤ 10 V 45 9 45 10 --------
11 10 45 10 ≤ 10 V 55 10 55 11 --------
12 11 55 11 ≤ 10 F -------- -------- -------- -------- 55
39
Ejemplo 2: un ciclo for que suma los números 8, 6, 4 y 2

En otras palabras: suma de los números pares desde el número 8 hasta el número 2
Pseudocódigo
/* sumatoriaFor-pseudo.c
* Pseudocódigo */
Inicio
j <- 0
suma <- 0
Desde j <--- 8 Hasta j > 0 Disminuir j en 2

suma <- suma + j
Imprimir j, suma
Fin desde
Imprimir "La suma es: " suma
Fin
40
Codificación
/* sumatoriaFor.c */
#include <stdio.h>
#include <math.h>
int main(){
int j;
int suma = 0;
printf("\nPrograma que suma los numeros 8, 6, 4 y 2 mediante un ciclo for");

printf("\nEn otras palabras: la suma de los numeros pares desde el numero 8 hasta el
numero 2");
printf("\n--------------------------------------------------------------------------------
---");
printf("\n---------------------");
for(j = 8; j > 0; j -=2){

suma += j;
printf("\nDebug: %d\t%d", j, suma);
}
printf("\nLa suma es: %d", suma);

return 0;
}
Sumatoria que suma los números 8, 6, 4, y 2

En otras palabras: la suma de los números pares desde el número 8 hasta el número 2
VERDAD FALSO
Imprimir
Número de
renglón suma j j > 0 Resp. suma = suma + j j suma j = j - 2 Imprimir suma
1 0 8 8>0 V 8 8 8 6 --------
2 8 6 6>0 V 14 6 14 4 --------
3 14 4 4>0 V 18 4 18 2 --------
4 18 2 2>0 V 20 2 20 0 --------
5 20 0 0>0 F -------- -------- -------- -------- 20
41
Ejemplo 3: algoritmo que calcula el promedio de ‘n’ calificaciones.
42
Pseudocódigo
/* promedio-n-calificaciones-pseudo.c */
Inicio
i, n <-- 0, x <-- 0, s <-- 0, p <-- 0
Mientras (n ≤ 0)
Imprimir "Ingresa el número de calificaciones a capturar: "
Leer n
Fin mientras
Desde i <-- 1 Hasta i ≤ n Incrementar i en 1

Imprimir "Ingresa la calificación " i ":"
Leer x
s <-- s + x
Fin desde
p <-- s / n
Imprimir "El promedio es: " p

Fin
43
Codificación
/* promedio-n-calificaciones.c */
#include<stdio.h>
#include<stdlib.h>
int main(){
int i, n = 0;
double x = 0.0, s = 0.0, p = 0.0;
printf("\n\nPrograma que calcula el promedio de 'n' calificaciones");

printf("\n-----------------------------------------------------------");
while (n <= 0){

printf("\n\nIngresa el numero de calificaciones a capturar: ");
scanf("%d", &n);fflush(stdin);
}
for (i = 1; i <= n; ++i){

printf("\nIngresa la calificacion %d : ", i);
scanf("%lf", &x);fflush(stdin);
s = s + x;
}
p = s / n;
printf("\n\nEl promedio de %d calificaciones es: %lf", n, p);
return 0;
}
Descripción
• Un ciclo for se utiliza cuando se incrementa o decrementa un contador que determina cuántas veces se
ejecutará el ciclo.
• Dentro del paréntesis del ciclo for, se codifica una expresión que es el valor con el que se inicia el contador;
en seguida se escribe una condición, que es una expresión booleana, la cual indica que mientras sea
verdadera la condición, se llevarán a cabo el contenido del ciclo. Por último, se escribe una expresión que
indica el incremento o decremento del contador.
• El ciclo finaliza cuando la condición, la cual es una expresión booleana, es falsa: 0
• Se debe declarar la variable que hace las veces de contador antes del ciclo, por lo que esta variable estará
disponible después de que concluya el ciclo.
44
1.4.4 Ciclos anidados

Dibujar la circunferencia unitaria, y a partir de ella, elaborar el análisis, diagrama de flujo, pseudocódigo y
codificación en lenguaje C, que imprima la siguiente tabla que está enmarcada, con base en los grados. Utilizar
algún ciclo. Desde luego, realizar la conversión de grados a radianes.
A B C D E F
Calcular Calcular Calcular Calcular Calcular Calcular
Ángulo β
Grados Radianes sen β cos β tan β P(x,y)
0 0 0 1 0 (1, 0)
45 0.7854 0.707106781 0.707106781 1 (0.707, 0.707)
90 1.5708 1 0 INFINITO (0, 1)
135 2.3562 0.707106781 -0.707106781 -1 (-0.707, 0.707)
180 2.1416 0 -1 0 (-1, 0)
225 3.927 -0.707106781 -0.707106781 1 (-0.707, -0.707)
270 4.7124 -1 0 INFINITO (0, -1)
315 5.4978 -0.707106781 0.707106781 -1 (0.707, -0.707)
360 6.2832 0 1 0 (1, 0)
Observar que en todas las columnas se deben realizar los respectivos cálculos, mediante las funciones
trigonométricas correspondientes.
Considerar los casos de tan(90°) y tan(270°), en donde ambos casos, su valor es INFINITO. Programar los dos casos
mediante una decisión.
Al final, el programa pregunta:

¿Desea volver a ejecutar el programa (S/N)? :
Si el usuario responde con el caracter ‘S’ o ‘s’, el programa se vuelve a ejecutar, de lo contrario, el programa
concluye.
Nota: para efectos del ejercicio, no imprimir el área sombreada.
45
46
/* circunferencia-unitaria-pseudo.c
* Pseudocódigo */
Inicio
i
opcion <- ' '
x <- 0, y <- 0, z <- 0
pi <- 3.14159265358979323846
Hacer
Imprimir "Circunferencia unitaria"
Imprimir " Angulo B"
Imprimir "Grados Radianes seno coseno tangente P(x, y)"
Imprimir "=============================================="
Desde i <- 0 Hasta i <= 360 Incremento i en 45

x <- sin(i * pi / 180)
y <- cos(i * pi / 180)
Imprimir i, i * pi / 180, x, y
Si (x = 1 OR x = -1)
Imprimir "Infinito"
Sino
z <- tan(i * pi / 180)
Imprimir z
Fin Si
Imprimir y, x
Fin desde
Imprimir "Desea volver a ejecutar el programa (S / N): "

Leer opcion
Mientras (opcion = 's') OR (opcion = 'S')

Fin
47
/* circunferencia-unitaria.c*/
#include <stdio.h>
#include <math.h>
int main(){
int i;
char opcion = ' ';
double x = 0.0, y = 0.0, z = 0.0;
const double pi = 3.14159265358979323846;
do{
printf("\n\n\nCircunferencia unitaria");
printf("\n===========================");
printf("\n\n Angulo B");
printf("\nGrados\tRadianes\tseno B\t\tcoseno B\ttangente B\t P(x, y)");
printf("\n====================================================================================
=====");
for(i = 0; i <= 360; i = i + 45){
x = sin(i * pi / 180.0);
y = cos(i * pi / 180.0);
printf("\n%d\t%.3lf\t\t%.3lf\t\t%.3lf", i, i * pi / 180.0, x, y);

if (x == 1.0 || x == -1.0){
printf("\t\tInfinito");
}
else{
z = tan(i * pi / 180.0);
printf("\t\t%lf", z);
}
printf("\t%.3lf\t%.3lf", y, x);
}
printf("\n\nDesea volver a ejecutar el programa (S / N): ");

scanf("%c", &opcion);fflush(stdin);
}while (opcion == 's' || opcion == 'S');

return (0);
}
48
1.5 Sentencia break

Cuando se codifican ciclos generalmente se ejecutan sin interrupciones. Sin embargo, en ocasiones una aplicación
puede requerir salir antes de que concluya el ciclo. Si se necesita salir de un ciclo (ejemplo 1 y 2), se codifica la
sentencia break.
Sintaxis de la sentencia break

break;
Estructura de la sentencia break
Ejemplo 1: una sentencia break que sale del ciclo for
49
Ejemplo 2: una sentencia break que sale del ciclo for
Descripción
• Para salir de un ciclo se usa la sentencia break.
• La función srand(u) inicializa el generador de números aleatorios. Esta instrucción es obligatoria para
generar números aleatorios.
50
1.6 Sentencia continue

La sentencia continue brinca a donde se ubica la instrucción del ciclo.
Sintaxis de la sentencia continue

continue;
Estructura de una sentencia continue
Ejemplo 1: sentencia continue que salta a donde se encuentra la sentencia do-while
51
Ejemplo 2: sentencia continue que salta a donde se encuentra la sentencia for
Descripción
• Se usa la instrucción continue para saltar a la instrucción en donde se ubica el ciclo.
• Es como una instrucción goto en otros lenguajes de programación.
52
Perspectiva
Si este capítulo se ha cubierto con éxito, el estudiante podrá usar las sentencias if, switch, while, do-while
y for. Éstas son sentencias de C que implantan las estructuras de selección, caso e iteración y proporcionan la
lógica de una aplicación.
Resumen
• Se pueden usar los operadores relacionales para crear expresiones lógicas que comparan tipos de datos y
regresan valores 1 o 0. Así mismo, se usan los operadores lógicos para conectar dos o más expresiones
lógicas.
• Las sentencias if/else y switch se utilizan para controlar la lógica de una aplicación y para anidar estas
sentencias cada vez que sea necesario.
• Las sentencias while, do-while y for se emplean para ejecutar ciclos. Dentro de los ciclos se encuentran
sentencias que se ejecutan repetidamente hasta que se evalúa una expresión lógica y ésta resulta en el valor
lógico 0. Se pueden anidar estas sentencias cada vez que sea necesario.
• La sentencia break se utiliza para salir de un ciclo. Se usa la sentencia continue para brincar a donde se
ubica la instrucción del del ciclo actual.
53

Sentencias Control

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Sentencias Control

Cargado por

Copyright:

Formatos disponibles

Sentencias de control

1.1 Expresiones lógicas

1.1.1 Comparar tipos de datos

Ejemplos de expresiones lógicas

/* Igualdad con un caracter

/* Igualdad con el valor 0

/*Desigualdad en una expresión numérica

/* Mayor que en una expresión numérica

/*Menor que con una variable

/* Mayor o igual que en una expresión numérica

/* Menor o igual que con una variable

Codificación de los ejemplos anteriores:

/* Igualdad en una expresión numérica

/* Igualdad con un caracter

/* Igualdad con el valor 0

/* Desigualdad en una expresión numérica

/* Mayor que en una expresión numérica

/* Menor que con una variable

/* Mayor o igual que en una expresión numérica

/* Menor o igual que con una variable

1.1.2 Operadores lógicos

esValido == 1 & contador++ < meses

(subTotal >= 250 && subTotal < 500) || esValido == 1

1.2 Sentencia if/else

Ejemplo 1: una sentencia if que contiene dos bloques de código

Ejemplo 2: una sentencia if con cláusulas else if y else

Ejemplo 3: sentencias if anidadas

1.2.1 Ejercicio de decisiones

Empresa Abarrotera “La surtidora”

Ingresar el tipo de cliente: M

1.2.1.1. Diagrama de entrada/salida

1.2.1.3 Árbol de decisiones

1.2.1.4 Diagrama de flujo

Imprimir "Desea volver a ejecutar el programa (S/N)?: "

while (opcion == 's' || opcion == 'S'){

printf("\n\nDesea volver a ejecutar el programa (S/N)?: ");

1.3 Sentencia switch case

cualquier otras sentencias case

Fin según sea

*/* Nombre del programa: dias-semana.c */

Si se vuelve a ejecutar el programa:

Si se vuelve a ejecutar el programa:

Fin según sea

e == 'a' e == 'b' e == 'c' e == 'd' Otros

Si se vuelve a ejecutar el programa:

Si se vuelve a ejecutar el programa:

Sintaxis del ciclo while

Diagrama de flujo del ciclo while

Ejemplo: Un ciclo while que calcula la sumatoria del 1 al 10

Mientras (i <= 10) Hacer

Imprimir "La suma del 1 al 10 es: " suma

printf("\nPrograma que suma del 1 al 10 mediante el ciclo while");

while (i <= 10){

printf("\nLa suma del 1 al 10 es: %d", suma);

Sumatoria del 1 al 10 mediante un ciclo while

1.4.2 Sentencia do-while

Sintaxis del ciclo do-while

Diagrama de flujo del ciclo do-while

Ejemplo: Un ciclo do-while que calcula la sumatoria del 1 al 10

Imprimir "La suma del 1 al 10 es: " suma

printf("\nPrograma que suma del 1 al 10 mediante el ciclo do - while");

printf("\nLa suma del 1 al 10 es: %d", suma);

Sumatoria del 1 al 10 mediante un ciclo do - while

/ Nombre del programa: dias-semana.c */