Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Sentencias Control
Sentencias 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.
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.
2
Sentencias de control
3
Sentencias de control
#include <stdio.h>
#include <math.h>
int main(){
4
Sentencias de control
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
Ejemplos
subTotal >= 250 && subtotal < 500
tiempo <=4 || tiempo >=12
!(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
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
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:
9
Sentencias de control
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:
Tipo de cliente:
M)ayorista
T)ienda
O)tro
********************************************
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.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
12
Sentencias de control
13
Sentencias de control
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
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;
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****************************************************");
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
case etiqueta2:
sentencias:
break;
case etiqueta3:
sentencias:
break;
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
22
Sentencias de control
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 ✓ ------- ------- ------- ------- ------- ------- -------
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
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
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
29
Sentencias de control
/* sumatoria10While-pseudo.c
* Pseudocódigo */
Inicio
i <-- 0
suma <-- 0
Fin
30
Sentencias de control
/* sumatoria10While.c */
#include <stdio.h>
#include <math.h>
int main(){
int i = 0;
int suma = 0;
31
Sentencias de control
32
Sentencias de control
/* 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
Sentencias de control
/* sumatoria10DoWhile.c */
#include <stdio.h>
#include <math.h>
int main(){
int i = 0;
int suma = 0;
do{
suma += i; // suma = suma + i;
printf("\nDebug: %d\t%d", i, suma);
++i;
} while (i <= 10);
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
Diagrama de flujo
36
Sentencias de control
37
Sentencias de control
/* sumatoria10For-pseudo.c
* Pseudocódigo */
Inicio
i
suma <-- 0
Fin
38
Sentencias de control
/* sumatoria10For.c */
#include <stdio.h>
#include <math.h>
int main(){
int i;
int suma = 0;
39
Sentencias de control
Pseudocódigo
/* sumatoriaFor-pseudo.c
* Pseudocódigo */
Inicio
j <- 0
suma <- 0
Fin
40
Sentencias de control
Codificación
/* sumatoriaFor.c */
#include <stdio.h>
#include <math.h>
int main(){
int j;
int suma = 0;
41
Sentencias de control
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
p <-- s / n
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;
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
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.
Si el usuario responde con el caracter ‘S’ o ‘s’, el programa se vuelve a ejecutar, de lo contrario, el programa
concluye.
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 "=============================================="
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
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("\t%.3lf\t%.3lf", y, x);
}
48
Sentencias de control
49
Sentencias de control
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
51
Sentencias de control
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