Las estructuras de control de flujo en un lenguaje especifican el orden en que se realiza el procesamiento de datos.
Las estructuras de selección (o condicionales) permiten realizar una u otra acción con base en una expresión lógica. Las acciones posibles a realizar son mutuamente excluyentes, es decir, sólo se puede ejecutar una a la vez, dentro de toda la estructura.
Lenguaje C posee tres estructuras de selección: la estructura if-else, la estructura switch y la estructura condicional o ternaria.
La estructura de control de flujo más simple es la estructura condicional if. Su sintaxis es la siguiente:
if (expresión_lógica) {
// bloque de código a ejecutar
}
En esta estructura se evalúa la expresión lógica y, si se cumple (si la condición es verdadera), se ejecutan las instrucciones del bloque, que se encuentra entre las llaves de la estructura. Si no se cumple la condición, se continúa con el flujo normal del programa.
Nota 1: Si el bloque de código a ejecutar consta de una sola línea de código no es necesario el uso de las llaves.
Nota 2: La expresión lógica evaluada regresará como resultado un número entero. Dentro de las estructuras de control 0 indica que la expresión lógica es falsa y cualquier número diferente de 0 indica que la expresión lógica es verdadera.
Código (estructura de control selectiva if)
#include<stdio.h>
/*
Este programa valida si el número a es mayor al número b.
*/
int main (){
int a, b;
a = 3;
b = 2;
if (a > b) {
printf("\ta (%d) es mayor a b (%d).\n", a, b);
}
printf("\t\vEl programa sigue su flujo.\n");
return 0;
}
Código (estructura de control selectiva if)
#include<stdio.h>
/*
Este programa comprueba que las condiciones evaluadas son numéricas
0 -> falso
≠ 0 -> Verdadero
*/
int main(){
if (0){
printf("Esta instrucción nunca se ejecuta\n");
printf("porque la condición siempre es falsa (0).\n");
}
if (-38)
// El bloque de código de esta estructura if
// sólo consta de una línea porque los comentarios
// no son tomados en cuenta por el compilador.
// La condición siempre es verdadera (diferente de 0)
printf("Esta instrucción siempre se ejecuta.\n");
return 0;
}
La sintaxis de la estructura de control de flujo if-else es la siguiente:
Asimismo, es posible anidar varias estructuras if-else, es decir, dentro de una estructura if-else tener una o varias estructuras if-else.
Código (estructura de control selectiva if-else)
#include <stdio.h>
/*
Este programa permite validar si un número es par o impar.
El número se lee desde la entrada estándar (el teclado).
*/
int main(){
int num;
printf("Ingrese un número:\n");
scanf("%d", &num);
if ( num % 2 == 0 )
printf("El número %d es par.\n", num);
else
printf("El número %d es impar.\n", num);
return 0;
}
Código (estructura de control selectiva if-else anidada)
#include <stdio.h>
/*
Este programa ordena en forma descendente tres valores enteros dados.
Los valores se leen desde la entrada estándar (el teclado).
*/
int main(){
int uno, dos, tres;
printf ("Ingrese 3 números separados por espacios:\n");
scanf ("%d %d %d", &uno, &dos, &tres);
if (uno > dos){
if (dos > tres){
printf("%d es mayor a %d que es mayor a %d\n", uno, dos, tres);
}else {
if (uno > tres) {
printf("%d es mayor a %d que es mayor a %d\n", uno, tres, dos);
} else {
printf("%d es mayor a %d que es mayor a %d\n", tres, uno, dos);
}
}
} else {
if (dos > tres){
if (tres > uno) {
printf("%d es mayor a %d que es mayor a %d\n", dos, tres, uno);
} else {
printf("%d es mayor a %d que es mayor a %d\n", dos, uno, tres);
}
} else {
printf("%d es mayor a %d que es mayor a %d\n", tres, dos, uno);
}
}
return 0;
}
La sintaxis de la estructura switch-case es la siguiente:
switch (opcion_a_evaluar){
case valor1:
/* Código a ejecutar*/
break;
case valor2:
/* Código a ejecutar*/
break;
…
case valorN:
/* Código a ejecutar*/
break;
default:
/* Código a ejecutar*/
}
Si la opción a evaluar no coincide dentro de algún caso, entonces se ejecuta el bloque por defecto (default). El bloque por defecto normalmente se escribe al final de la estructura, pero se puede escribir en cualquier otra parte. Si se escribe en alguna otra parte el bloque debe terminar con la palabra reservada break.
Código (estructura de control selectiva switch-case)
#include <stdio.h>
/*
Este programa permite elegir una opción del menú a partir del carácter ingresado. La opción se lee desde la entrada estándar (el teclado).
*/
int main(){
char op = '\0';
printf("\tMenú\n\n");
printf("Elegir la opción deseada\n");
printf("a) Ingresar\n");
printf("b) Registrarse\n");
printf("c) Salir\n");
scanf("%c",&op);
switch(op) {
default:
printf("Opción no válida.\n");
break;
case 'a':
printf("Se seleccionó 'Ingresar'.\n");
break;
case 'b':
printf("Se seleccionó 'Registrarse'.\n");
break;
case 'c':
printf("Se seleccionó 'Salir'.\n");
break;
}
return 0;
}
Código (estructura de control selectiva switch-case)
#include <stdio.h>
/*
Este programa permite elegir una opción del menú a partir del entero
ingresado. La opción se lee desde la entrada estándar (el teclado).
int main(){
int op = 0;
printf("\tMenú\n\n");
printf("Elegir la opción deseada\n");
printf("1) Ingresar\n");
printf("2) Registrarse\n");
printf("3) Salir\n");
scanf("%d",&op);
switch(op) {
case 1:
printf("Se seleccionó 'Ingresar'\n");
break;
case 2:
printf("Se seleccionó 'Registrarse'\n");
break;
case 3:
printf("Se seleccionó 'Salir'\n");
break;
default:
printf("Opción no válida\n");
}
return 0;
}
Existe otro tipo de dato constante conocido como enumeración. Una variable enumerador se puede crear de la siguiente manera:
enum identificador {VALOR1, VALOR2, ... , VALORN};
Para crear una enumeración se utiliza la palabra reservada enum, seguida de un identificador (nombre), y entre llaves se ingresan los nombres de los valores que puede tomar dicha enumeración, separando los valores por coma. Los valores son elementos enteros y constantes (por convención, se escriben con mayúsculas).
Ejemplo:
enum boolean {FALSE, TRUE};
La enumeración se llama 'boolean' y contiene dos elementos; el primero (FALSE) posee el valor 0 y el siguiente (TRUE) posee el valor 1. Si hubiese más elementos en la enumeración, la numeración correría de manera ascendente.
Es posible cambiar el valor de un elemento; para ello, sólo se le asigna el valor deseado:
enum diasSemana {LUNES, MARTES, MIÉRCOLES=5, JUEVES, VIERNES};
Código (variables tipo enumeración)
#include <stdio.h>
/*
Este programa crea diversas variables tipo enum (enumerador) y
permite visualizar la manera en la que se maneja el tipo de dato.
int main(){
// declaración de la enumeración
enum boolean {NO, YES};
// declaración de una variable tipo enumeración
enum boolean valorBooleano;
valorBooleano = YES;
// Se comprueba que el valor de una enumeración es entero
printf("%d\n", valorBooleano);
// Se comprueba que el valor de una enumeración se puede reasignar
enum diasSemana {LUNES, MARTES, MIERCOLES=5, JUEVES, VIERNES};
printf("\n%d", LUNES);
printf("\n%i", MARTES);
printf("\n%d", MIERCOLES);
printf("\n%i", JUEVES);
printf("\n%d\n", VIERNES);
return 0;
}
Código (variables tipo enumeración)
#include <stdio.h>
/*
Este programa permite elegir una opción del menú a partir del entero ingresado. La opción se lee desde la entrada estándar (el teclado).
*/
int main(){
// Los valores de una enumeración son enteros y constantes
enum diasSemana {LUNES, MARTES, MIÉRCOLES, JUEVES, VIERNES, SÁBADO, DOMINGO};
int op;
printf("Ingrese el día de la semana.\n");
printf("1) Lunes\n");
printf("2) Martes\n");
printf("3) Miércoles\n");
printf("4) Jueves\n");
printf("5) Viernes\n");
printf("6) Sábado\n");
printf("7) Domingo\n");
scanf("%d", &op);
switch(op-1){
case LUNES:
case MARTES:
printf("Inicio de semana.\n");
break;
case MIÉRCOLES:
printf("Mitad de semana.\n");
break;
case JUEVES:
printf("¡Casi inicia el fin de semana!\n");
break;
case VIERNES:
case SABADO:
printf("¡Fin de semana!\n");
break;
case DOMINGO:
printf("Día de descanso.\n");
break;
// No se necesita default
}
return 0; // Valor entero en hexadecimal
}
En C existen La estructura condicional (también llamada operador ternario) permite realizar una comparación rápida. Su sintaxis es la siguiente:
Condición ? SiSeCumple : SiNoSeCumple
Consta de tres partes, una condición y dos acciones a seguir, con base en la expresión condicional. Si la condición se cumple (es verdadera) se ejecuta la instrucción que se encuentra después del símbolo ‘?’. Si la condición no se cumple (es falsa) se ejecuta la instrucción que se encuentra después del símbolo ‘:’.
Código (estructura de control selectiva condicional o ternaria)
#include <stdio.h>
Este programa permite calcular el error matemático a partir de dos valores (a y b) ingresados desde la entrada estándar (el teclado), a partir de la fórmula:
E = |a – b|
Donde a es el valor real y b es el valor aproximado o viceversa.
*/
int main(){
double a, b, res;
printf("Calcular el error matemático E = |a - b|\n\n");
printf("Ingrese el valor de a:\n");
scanf("%lf", &a);
printf("Ingrese el valor de b:\n");
scanf("%lf", &b);
res = a < b ? b-a : a-b;
printf("El error matemático de\n");
printf("| %lf - %lf | es %lf\n", a, b, res);
return 0;
}
Ahora que ya sabemos cómo funcionan las estructuras de control selectivas (if, if-else, switch y ternaria), pondremos en práctica su uso, para que un programa se comporte de distintas maneras, dependiendo los datos de entrada.
Las estructuras de selección son muy útiles para realizar programas que se comporten de manera distinta, dependiendo de la información que el usuario ingrese; es decir, se puede hacer que el programa sea interactivo. La forma más común es mediante las pantallas tipo menú, en donde se le muestran varias opciones al usuario, y dependiendo cuál elija, el programa realizará diferentes acciones relacionadas con la opción elegida.
Para lograr introducir la toma de decisiones en un programa de computadora se cuentan con las estructuras de selección. Es importante conocerlas para poder crear programas versátiles y utilizarlas de manera óptima.
Fuentes de información
Kernighan, B., Ritchie, D. (1991). El lenguaje de programación C. Ciudad de México: Pearson Educación.
Solano, J., García, E., Sandoval, L., Nakayama, A., Arteaga, I. y Castañeda, M. (2016). Manual de prácticas del laboratorio de Fundamentos de programación. Facultad de Ingeniería. Consultado de http://lcp02.fi-b.unam.mx
Cómo citar
Arteaga, T. I. y Nakayama, M. A. (2018). Estructuras de selección. Unidades de Apoyo para el Aprendizaje. CUAED/Facultad de Ingeniería-UNAM. Consultado el (fecha) de (vínculo)
