Está en la página 1de 53

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
Sentencias de control

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
Sentencias de control

/* 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
Sentencias de control

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
Sentencias de control

/* 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
Sentencias de control

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
Sentencias de control

1.2 Sentencia if/else


Sintaxis de la sentencia if/else
if (expresionBooleana) {sentencias}
[else if (expresionBooleana) {sentencias}]…
[else {sentencias}]

Diagrama de flujo

7
Sentencias de control

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
Sentencias de control

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'){
porcentajeDescuento = 0.2;
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


double porcentajeDescuento = 0.0;
if (subTotal > 0.0 && subTotal < 200.0)
porcenajeDescuento = 0.1;
else if (subTotal >= 200.0 && subtotal < 300.0)
porcentajeDescuento = 0.2;
else if (subTotal >= 300.0)
porcentajeDescuento = 0.3;
else
porcentajeDescuento = 0.35;

Ejemplo 3: sentencias if anidadas


double porcentajeDescuento = 0.0;
if tipoCliente = 'M'){
if (subTotal >= 100)
porcentajeDescuento = 0.2;
else
porcentajeDescuento = 0.1;
}
else
porcentajeDescuento = 0.4;

9
Sentencias de control

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
Sentencias de control

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
Sentencias de control

1.2.1.3 Árbol de decisiones

12
Sentencias de control

13
Sentencias de control

1.2.1.4 Diagrama de flujo

14
Sentencias de control

15
Sentencias de control

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
Si (venta >= 1000 AND venta < 25000)
porcentajeDescuento <- 0.3
Sino
porcentajeDescuento <- 0.4
Fin Si
Fin Si
Sino
Si (cliente = 'T')
Si (venta >= 0 AND venta < 3000)
porcentajeDescuento <- 0.1
Sino
porcentajeDescuento =<-0.2
Fin Si
Sino
porcentajeDescuento <- 0.1
Fin Si
Fin Si

16
Sentencias de control

// 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
Sentencias de control

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){
porcentajeDescuento = 0.0;
}
else{
if (venta >= 1000.0 && venta < 25000.0){
porcentajeDescuento = 0.3;
}
else{
porcentajeDescuento = 0.4;
}
}
}
else{
if (cliente == 'T'){
if (venta >= 0.0 && venta < 3000.0){
porcentajeDescuento = 0.1;
}
else{
porcentajeDescuento = 0.2;
}
}
else{
porcentajeDescuento = 0.1;
}
}

18
Sentencias de control

// 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
Sentencias de control

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
Sentencias de control

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
Sentencias de control

/* 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
Sentencias de control

*/* 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");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 3:
printf("\nMartes");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 4:
printf("\nMiercoles");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 5:
printf("\nJueves");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 6:
printf("\nViernes");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 7:
printf("\nSabado");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

default:
printf("\nError: numero fuera de rango.");
printf("\n\nPresione una tecla para continuar...");
getch();
break;
}
return 0;
}

23
Sentencias de control

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
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 3 ------- ------- ✓ ------- ------- ------- ------- -------

Si se vuelve a ejecutar el programa:


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 9 ------- ------- ------- ------- ------- ------- ------- ✓

24
Sentencias de control

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
Sentencias de control

/* 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
Sentencias de control

/* 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");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 'b':
printf("\nVerano");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 'c':
printf("\nOtoño");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

case 'd':
printf("\nInvierno");
printf("\n\nPresione una tecla para continuar...");
getch();
break;

default:
printf("\nError: letra fuera de rango.");
printf("\n\nPresione una tecla para continuar...");
getch();
break;
}
return 0;
}

27
Sentencias de control

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 ✓ ------- ------- ------- -------

Si se vuelve a ejecutar el programa:


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 '' d ------- ------- ------- ✓ -------

Si se vuelve a ejecutar el programa:


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 '' 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
Sentencias de control

1.4 Ciclos
1.4.1 Sentencia while

Sintaxis del ciclo while


while (expresionBooleana){
sentencias
}

Diagrama de flujo del ciclo while

29
Sentencias de control

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
Sentencias de control

/* 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
Sentencias de control

1.4.2 Sentencia do-while

Sintaxis del ciclo do-while


do{
sentencias
} while (expresionBooleana

Diagrama de flujo del ciclo do-while

32
Sentencias de control

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)

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

Fin

33
Sentencias de control

/* 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\n\ti\tsuma");
printf("\n---------------------");

do{
suma += i; // suma = suma + i;
printf("\nDebug: %d\t%d", i, suma);
++i;
} while (i <= 10);

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


return 0;
}

Sumatoria del 1 al 10 mediante un ciclo do - while


Prueba de escritorio
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
Sentencias de control

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
Sentencias de control

1.4.3 Ciclo for


Sintaxis del ciclo for
for(expresionInicalizacion; expresionBooleana; expresionIncrementoDecremento){
sentencias
}

Diagrama de flujo

36
Sentencias de control

37
Sentencias de control

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

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

Fin

38
Sentencias de control

/* 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\n\ti\tsuma");
printf("\n---------------------");

for(i = 0; i <= 10; ++i){


suma += i; // suma = suma + i;
printf("\nDebug: %d\t%d", i, suma);
}

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


return 0;
}

Sumatoria del 1 al 10 mediante un ciclo for


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

39
Sentencias de control

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
Sentencias de control

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\n\ti\tsuma");
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
Prueba de escritorio
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
Sentencias de control

Ejemplo 3: algoritmo que calcula el promedio de ‘n’ calificaciones.

42
Sentencias de control

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
Sentencias de control

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
Sentencias de control

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
Sentencias de control

46
Sentencias de control

/* 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
Sentencias de control

/* 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
Sentencias de control

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
Sentencias de control

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
Sentencias de control

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
Sentencias de control

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
Sentencias de control

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

También podría gustarte