Uncategorized

Programando en C: Estructuras de control

Capítulo 9: Estructuras de control

¿Qué son las estructuras de control?

Las estructuras que vamos a ver en este capítulo nos permiten controlar el flujo de la información a lo largo de un programa.

Un programa, tal y como lo hemos visto hasta ahora, es una sucesión de instrucciones que acaban llevando a un resultado fijo y concreto.

Sin embargo, hay ocasiones en las que un programa no tiene un único resultado, sino que puede tener diferentes resultados, puede tener diferentes secciones, y la ejecución de unas secciones uno tras dependerá de las decisiones que nosotros tomemos durante la ejecución de dicho programa.

El objetivo de este apartado, es precisamente presentar y mostrar estas estructuras de control, que forman parte Del núcleo de cualquier lenguaje de programación, y además, encontraremos las mismas estructuras, o prácticamente iguales, a lo largo de diferentes lenguajes, durante nuestro proceso de aprendizaje.

Estructuras condicionales

El flujo de ejecución de un programa puede ser modificado mediante la aparición de estructuras condicionales, es decir, mediante la ejecución condicional de un código o otro, después de la validación de una condición previa.

fundamentalmente existen dos tipos de estructura condicional, que son las que vamos a presentar a continuación.

La primera es la estructura condicional es, que se encarga de ejecutar un código y otro mediante la validación verdadero falso de una expresión, y la segunda es la estructura condicional switch, que admite varios casos de manera simultánea como verdadero

La estructura condicional

anteriormente hemos hablado de que el lenguaje nativo en el que habla una computadora es el binario, compuesto de unos y ceros, que, finalmente, representan el estado encendido y apagado de cada uno de los componentes más básicos del lenguaje de programación.

Así que, finalmente, la validación mediante estados de verdadero y falso es una validación bastante cercana para lo que es la naturaleza del lenguaje con el que trabaja la máquina, a diferencia del lenguaje con el que trabaja el ser humano, que entre blanco y negro distingue una variedad bastante grande de grises, por regla general.

la estructura de control, por tanto, contiene en primer lugar una expresión que, finalmente, puede ser validada como verdadera o cierta.

A continuación, tiene un bloque de código, que solo se ejecutará en el caso de que la expresión validada sea cierta.

Adicional y opcionalmente, la expresión puede tener un caso Els, es decir, un caso que solo se ejecutará en el caso de que la expresión haya sido validada como falsa.

Es por esto que, por ejemplo, podríamos expresar una estructura de control es de la siguiente manera:

main.c
#include <stdio.h>
int main(int argc, char *argv[]) {    int edad = 40;    if(edad < 30){        printf(«Eres un joven»);    }else{        printf(«Ya no eres tan joven»);    } return 0;}

Alización de las estructuras de control condicionales

Las estructuras de control pueden ser perfectamente anidadas, para ofrecer validaciones más complejas que el ejemplo que hemos visto con anterioridad.

De esta forma, con respecto al ejemplo anterior, dentro de cada uno de los casos, podemos introducir a su vez otra estructura completa de validación condicional.

Si aplicamos esta validación sobre el ejercicio que mostrado anteriormente, podemos encontrar que, ahora, la salida del programa, ya no se limita a dos estados, sino que puede resultar en cuatro.

Evidentemente, puedo repetir este proceso iterativa mente tantas veces como necesites, para conseguir que la estructura general tantos estados como yo necesite

main2.c
#include <stdio.h>
int main(int argc, char *argv[]) {    int edad = 40;    if(edad < 30){        if(edad < 20){            printf(«Eres muy joven»);        }else{            printf(«Eres un joven»);        }            }else{        if(edad < 40){           printf(«Ya no eres tan joven»);         }else{            printf(«Definitivamente ya no eres joven»);        }            } return 0;}

Aplicación de operadores en la validación de la expresión

Por supuesto, teniendo en cuenta que, finalmente, se valida una expresión como verdadera o falsa, podemos aplicar todo aquello que hemos aprendido anteriormente en cuanto al uso de operadores.

Es por esto que es frecuente observar el uso de operadores lógicos dentro de la expresión validada en una estructura de control condicional, por ejemplo, de la siguiente manera

main.c


La estructura de control condicional switch

Hasta el momento, con la estructura de Control condicional ismos o Els es, finalmente lo que hacemos es validar una expresión en cuanto a su veracidad o su falsedad.

Sin embargo, existen infinidad de casos donde no hay una validación verdadera y una falsa, sino que puede haber muchas variaciones verdaderas infinitas validaciones falsas.

Un ejemplo claro y clásico de esto, son los días de la semana.

Si yo pregunto, qué día de la semana es hoy? La respuesta a esa pregunta no es verdadero o falso.

La respuestas correctas son lunes, martes, miércoles, jueves, viernes, sábado, y domingo, y hay infinidad de otras respuestas incorrectas, pero en definitiva sabemos que hay al menos siete respuestas verdaderas.

La estructura de control switch trata específicamente este tipo de preguntas, en definitiva, preguntas para las que no hay un solo caso verdadero.

Así que, el ejemplo planteado en el párrafo anterior, el ejemplo de los días de la semana, quedaría reflejado en el siguiente código

main.c

#include <stdio.h>
int main(int argc, char *argv[]) {    int dia = 1;        switch(dia){        case 1:            printf(«Hoy es lunes»);            break;        case 2:            printf(«Hoy es martes»);            break;        case 3:            printf(«Hoy es miercoles»);            break;        case 4:            printf(«Hoy es jueves»);            break;        case 5:            printf(«Hoy es viernes»);            break;        case 6:            printf(«Hoy es sabado»);            break;        case 7:            printf(«Hoy es domingo»);            break;    } return 0;}

Como podemos ver, a la estructura de control tiene una serie de componentes similares a cualquier otra estructura, tiene el nombre de la propia estructura, entre paréntesis la expresión que se está validando, y dentro de las llaves, se escriben cada uno de los casos que trata la expresión como posibles casos válidos.

debemos fijarnos en que lo que hay después de la palabra clave caso son: y no un punto y,.

Por otra parte, también deberemos tener en cuenta que cada uno de los casos deberá acabar con una instrucción break.

Una vez que se ha ejecutado uno de los casos verdaderos, la instrucción break impide que se ejecuten el resto de casos en cascada.

El caso default

En el ejemplo anterior, en el caso switch, hemos visto como la estructura de control puede reaccionar a una serie de casos verdaderos, pero, qué es lo que ocurre cuando se introduce un caso falso?

Por defecto, cuando ocurre que el usuario introduce un caso que no es válido, por defecto la estructura de control no realiza una acción.

De esta forma, siguiendo los patrones de la programación defensiva, existe un último caso dentro de la estructura switch llamado de Ford, que se encarga de gestionar precisamente como debe comportarse la estructura de control cuando se le introduce un caso no válido.

De esta forma, la estructura de control quedaría de la siguiente manera:

main.c
#include <stdio.h>
int main(int argc, char *argv[]) {    int dia = 15;        switch(dia){        case 1:            printf(«Hoy es lunes»);            break;        case 2:            printf(«Hoy es martes»);            break;        case 3:            printf(«Hoy es miercoles»);            break;        case 4:            printf(«Hoy es jueves»);            break;        case 5:            printf(«Hoy es viernes»);            break;        case 6:            printf(«Hoy es sabado»);            break;        case 7:            printf(«Hoy es domingo»);            break;        default:            printf(«Entrada no reconocida»);            break;    } return 0;}

La estructura de control condicional else if

Prácticamente el mismo resultado que hemos conseguido mediante el uso de la estructura de control switch, podríamos conseguirlo mediante la estructura de control el cif, que en principio es una variación a la estructura de control y que ha sido presentado anteriormente

 el ejercicio, de esta manera, quedaría transformado en el siguiente código 

main.c


Sin embargo, procediendo de esta manera, no estaremos evaluando realmente el potencial que tiene la estructura de control el cif, ya que en cada una de las condiciones evaluadas, podemos introducir un nivel mayor de complejidad que en la estructura de control switch

 de esta forma, el siguiente ejemplo aprovecha bastante mejor el potencial de extra estructura, comparada con la estructura de control switch 

main.c


Sobre el ejercicio del curso:

A continuación aplicamos lo que hemos aprendido en la presente unidad didáctica al desarrollo del ejercicio continuo de la publicación

 sí en unidades anteriores hemos preparado una variable de tipo carácter para almacenar la elección del usuario, a continuación, utilizamos una estructura de control de tipo suite para poder reaccionar de diferente forma dependiendo de la elección que efectivamente haya realizado el usuario humano 

agenda.c
/* Programa agendapor Jose Vicente Carratala */#include <stdio.h>#define NOMBREPROGRAMA «Programa agenda»#define VERSION «1.0»#define AUTOR «Jose Vicente Carratala»
int main(int argc, char *argv[]) {    // Mensaje de bienvenida printf(«%s v%s \n»,NOMBREPROGRAMA,VERSION); printf(«%s \n»,AUTOR); printf(«\t 1 – Listado de registros \n»); printf(«\t 2 – Introducir un registro \n»); printf(«\t 3 – Eliminar un registro \n»); printf(«\t 4 – Buscar un registro \n»); printf(«\t 5 – Actualizar un registro \n»); printf(«Tu opcion: «); char opcion = getchar(); printf(«La opción que has seleccionado es: %c \n»,opcion); switch(opcion){     case ‘1’:         printf(«Vamos a listar los registros»);         break;        case ‘2’:         printf(«Vamos a introducir un registro»);         break;        case ‘3’:         printf(«Vamos a eliminar un registro»);         break;        case ‘4’:         printf(«Vamos a buscar un registro»);         break;     case ‘5’:         printf(«Vamos a actualizar un registro»);         break;        default:            printf(«La opción que has introducido no es válida»);            break; } return 0;}

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *