Hola y bienvenido. En esta conferencia, quiero hablar sobre la declaración de cambio.
Es una alternativa a una declaración
if, pero generalmente se usa solo en situaciones específicas.
Pero tiene una sintaxis agradable y genial para hacer algunas repeticiones en su declaración if.
Por lo tanto, el operador condicional y las declaraciones if
than else facilitan la escritura de programas que eligen entre dos alternativas.
Es muy fácil hacer preguntas y tomar decisiones.
Sin embargo, muchas veces,
un programa debe elegir una de varias alternativas.
Y esto sería esencialmente
el if else if else if else if else if.
Es complicado porque obviamente puede implementar esto con la declaración if cuando
tiene varias alternativas, pero
podría tener cientos de ifs más. Así que es tedioso, propenso a errores y en
realidad es solo un dolor de cabeza. Es como escribir un montón de código repetitivo.
Entonces, la alternativa a esta sintaxis y todo lo que puede hacer
en el conmutador lo puede hacer en un if.
Pero es más limpio y más fácil y en realidad también es mucho más eficiente.
Entonces, cuando el valor de una variable se compara con éxito con diferentes valores, use
la instrucción switch.
Y lo que esto significa si tiene una instrucción if y luego tiene una else if, else if, else if,
else if, else if, else if, use la instrucción switch.
Ahora si esas expresiones booleanas son un poco más complicadas.
No puede usar una declaración de cambio. Solo puede usar
una declaración de cambio cuando está comparando con un valor, como una constante.
La expresión no puede ser tan complicada.
Pero es mucho más conveniente y muy eficiente usar la instrucción switch, y la mayoría de
los lenguajes también tienen esta construcción. Y mira que es muy bonito. Lo único que notará
que muchos lenguajes se construirán en base a c.
Si ha programado antes, verá
y estará familiarizado con muchas de
estas construcciones porque originalmente aparecieron en c o be, el lenguaje anterior.
Así que aquí está la sintaxis de una declaración de cambio. Tienes la palabra clave switch.
Y luego, dentro del interruptor, tienes estos paréntesis izquierdo y derecho,
que es la expresión. Por lo tanto, se parece a la instrucción if
al principio, excepto que en lugar de la palabra clave if, tiene la palabra clave switch.
Luego tienes el corchete izquierdo.
Se requieren los corchetes izquierdos. Ese corchete izquierdo inicia el cuerpo del interruptor.
Y ves el corchete final derecho en la parte inferior, que termina el cuerpo del interruptor.
La otra cosa que es importante aquí es el caso de estas palabras clave.
El caso es en realidad como la
declaración if en sí. Entonces, Switch en
realidad va a mirar una expresión,
no si es necesariamente verdadera o falsa.
El interruptor podría estar mirando una variable o algo.
Y luego evaluará esa variable en las declaraciones del caso.
Entonces, si el valor 1 es igual a la expresión,
si el valor n es igual a la expresión.
Pero puede ver esto como si
el interruptor estuviera en el nivel superior y luego los casos fueran una
declaración if, comparando los valores con las expresiones en el interruptor.
Así que los casos también son palabras clave. También nota los dos puntos después del caso.
Entonces tienes caso y luego tienes tu valor.
Y luego, adentro, puede tener múltiples declaraciones de programa.
Y luego, al final, tienes una palabra clave de descanso. Esa es otra palabra clave. Así que aquí hay
tres palabras clave, en realidad cuatro. Está la palabra clave switch, la palabra clave case, la palabra clave
break y luego la predeterminada en la parte inferior.
Entonces, estas son las cosas importantes a tener en cuenta. Veremos un ejemplo
detallado, pero puede tener diferentes casos. Y de nuevo, esto es simplemente como un si más, si más, si más, si no.
Entonces, si el valor uno es una expresión igual, ejecute el código.
De lo contrario, si el valor dos es igual
a la expresión, evalúe eso. De lo contrario, si el valor tres es igual a la expresión, evalúe eso.
De lo contrario, si el valor n es igual a la expresión, ejecute el código dentro de ese bloque.
Y el bloque para los casos comienza con los dos puntos y termina con la ruptura.
Y si no tiene esa ruptura allí,
caerá en los otros casos. Vamos a hablar de eso nuevamente.
Y luego, lo último que es importante aquí es esta palabra clave predeterminada. Esto es esencialmente el else, else
if, else if, else if y luego else en la parte inferior.
Entonces, esto se establece si ninguno de los otros casos se evalúa en la expresión.
Así que hablemos de algunos de esos detalles que mencioné.
La expresión encerrada entre paréntesis se compara con éxito con los valores.
De nuevo,
si volvemos a la sintaxis, la expresión se compara con todos los valores.
Y si equivale a alguno de los valores, ejecuta el código dentro de ese valor.
Los casos deben ser constantes simples o expresiones constantes, expresiones
que se evalúan como una constante.
Entonces, podría activar x más y porque
si x es 5, simplemente activaría 10 y compararía los valores con 10.
Pero, por lo general, activa una variable que es igual a algún tipo de número.
Si se encuentra un caso cuyo valor es igual al valor de la expresión,
se ejecutan las declaraciones que siguen al caso.
Cuando se incluye más de una declaración, no es necesario que se cierren entre llaves.
Eso es solo decir que
cuando se incluye más de una declaración, no
se requieren llaves para las declaraciones del caso.
Recuerde, para la declaración if, siempre tendríamos que tener
esos frenos, ese no es el caso. Puede ponerlos una línea tras otra, la clave es la ruptura allí.
La sentencia break señala el final del caso particular
y hace que la ejecución de la sentencia
finalice, salta.
Si no tiene la ruptura allí, el próximo caso fracasará.
Por lo tanto, desea incluir el final de la declaración de interrupción de cada caso. Cuando no incluye descansos, generalmente significa
que hay un error o algo.
La única razón por la que desea incluir una interrupción es si tenía varias condiciones
en las que deseaba ejecutar el código. Entonces, si tuviera varios casos,
básicamente diciendo si la expresión
era este caso, este caso o ese caso,
haga lo mismo,
entonces eliminaría los descansos.
Así que tenga cuidado con las rupturas porque las rupturas pueden
causar problemas si ciertos bloques se ejecutan o no en el siguiente caso.
El caso opcional especial llamado predeterminado se ejecuta si el valor de la
expresión no coincide con ninguno de los casos. Es lo mismo que una caída, de lo contrario sucede
si ninguno de los casos es cierto.
Así que aquí hay un buen ejemplo en el que estamos creando un interruptor para evaluar una enumeración.
En este caso, tenemos un tipo de enumeración llamado día de la semana, que
solo se especifica en todos los días de la semana.
Y luego creamos una variable de tipo enum weekday y la configuramos en Monday y
luego la encendemos hoy.
Entonces, dependiendo del valor de hoy, la variable, se ejecutará
una de las declaraciones de caso.
Si hoy es igual al domingo, se imprimirá hoy
es domingo y luego saltará.
Si hoy es igual al lunes, se imprimirá hoy es lunes y saltará.
Si no es igual a
ninguno de ellos, pasará al caso predeterminado. Así que repasemos este ejemplo en bloques de código.
Aquí tenemos nuestro código de muestra. Y verá eso porque hoy es igual
al lunes, en caso de que
el lunes se evalúe y verá la salida de hoy es lunes.
Así que sigamos adelante, creemos este código y ejecútelo. Y eso es lo que vamos a ver,
hoy es lunes.
Porque lo que pasa aquí es que hoy será el lunes. Pones esta expresión en
la que quieres evaluar la variable hoy y luego la evalúas.
Las cosas clave que debe recordar aquí son que
tiene un corchete para iniciar la instrucción de cambio en la línea 16 en
un corchete final para terminar el nombre del interruptor en la línea 29.
Puede tener varias líneas dentro de cada declaración de caso sin usar corchetes.
Ahora veamos qué sucede si eliminamos la
declaración de interrupción después del lunes.
Porque recuerde, la rotura saltará directamente del caso. Pero si lo
eliminamos, lo que sucederá es que
se caerá hasta el martes y verá que ambos printfs
se ejecutan para hoy lunes y hoy es martes.
Así que ahora, cuando ejecutamos el
programa, vemos que hoy es lunes, hoy es martes.
Esa es la importancia de la declaración de ruptura.
La ruptura salta.
Por tanto, esto podría resultar útil si desea obtener el mismo resultado para el lunes y el martes.
Entonces, por ejemplo, a veces verá declaraciones
de casos como esta, caso martes porque desea el mismo resultado
y no importa a qué es igual la variable.
Entonces puede ver cosas así, pero cuando tiene declaraciones de casos separadas
que tienen una ejecución diferente, debe agregar esa interrupción allí.
Así que solo estamos viendo el domingo, el lunes y el martes.
¿Qué sucede si establecemos el valor de hoy igual al domingo porque
no hay casos que vayan a coincidir con eso?
Bueno, lo que va a pasar es que no cumplirá con los valores predeterminados e imprimirá lo que sea.
Intentemos ejecutar esto de nuevo.
Y vemos que hoy es domingo.
Lo siento, configúrelo con la variable incorrecta. Quiero configurarlo, digamos,
miércoles. Teníamos un caso para el domingo.
Así que ahora veremos que en realidad imprime lo que sea porque no
coincidió con ninguno de los casos.
Así que todo lo que tienes que hacer para cambiar es realmente memorizar la sintaxis.
La expresión va entre paréntesis, eso es lo que vas a evaluar.
Los casos deben coincidir con la expresión. Por lo general, estás haciendo variables, por eso
tienen que ser constantes o expresiones que se evalúan a un valor constante específico.
Y luego tiene casos para cada cosa y luego un caso predeterminado para todos, y no se olvide de los descansos.
Regresemos y hablemos un poco más y otro ejemplo de la construcción
del interruptor con casos.
En el siguiente ejemplo, es un poco diferente.
Lo que estamos haciendo aquí es obtener datos del usuario y luego activarlos.
Entonces, en este ejemplo en nuestra función principal, comienza creando un par
de flotantes y luego crea un operador de carácter y luego le pide al usuario
que ingrese un valor, un operador y un valor dos.
Y está usando especificadores de formato para distinguir, y todos tienen una dirección de ampersands.
Dependiendo del carácter que ingrese para el operador, ya sea más menos o estrella, eso es lo
que desea incluir en su caso de interruptor.
Entonces, si el usuario ingresó un signo
más, lo que ve en la siguiente columna aquí, la construcción del interruptor, es el operador de encendido.
Se comparará el valor del operador, el valor del operador variable con cada una
de estas declaraciones de casos. Y notará que estas declaraciones
de casos tienen comillas simples alrededor porque estamos comparando caracteres.
Por lo tanto, puede
comparar números, variables con valores, constantes específicas o caracteres con constantes específicas.
Y luego, dentro de cada declaración de caso, imprimimos un formato específico.
Valor uno más valor dos, valor uno menos valor dos.
De hecho, estamos realizando cálculos en nuestra impresión.
Y luego nuevamente ves esas importantes declaraciones de ruptura
que están saliendo, y son necesarias si no quieres caer en ninguno de los otros casos.
También notará que en la última declaración de caso donde tiene la barra diagonal del divisor,
tenemos una declaración if.
No tenemos corchetes alrededor del caso
porque podemos tener múltiples declaraciones en cada caso sin corchetes.
Entonces, en el último caso, decimos que si el valor dos es igual a 0,
estamos haciendo una pequeña verificación para asegurarnos de que no dividimos entre 0.
Y si no dividimos entre 0, entonces realmente realizaremos nuestra división.
Y luego, al final de ese caso, tenemos otro descanso.
Nuestro caso predeterminado es decir que ingresó un operador que no sabemos cómo manejar.
Pero la declaración de cambio es muy eficiente.
Es muy rápido de escribir cuando comparas
muchos valores diferentes con una variable específica y luego quieres hacer cosas diferentes.
Lo último que quería mencionar era la declaración go to en relación con la toma de decisiones.
No es una declaración de
decisión directa, es más bien saltar a una línea de código diferente, usando una
etiqueta, pero está disponible en c, y es por eso que quería mencionarlo.
Hay dos partes en la declaración go to, la etiqueta y la palabra clave go to.
Ahora, para aquellos de ustedes que han
programado antes en Fortran o en algunos otros lenguajes básicos, probablemente lo reconocerán y
probablemente lo hayan usado bastante.
Ahora que viene ac, no hay necesidad
de usarlo realmente. Hay un par de casos
en los que vi que era bastante útil, que explicaré en un segundo, pero el paso es saltar
a algún código, y podría ir a cualquier línea de código.
Una de las razones por las que a la gente no le gusta usarlo porque es muy difícil de seguir.
Cuando está manteniendo un programa y si es secuencial, va línea por
línea, declaraciones if en los bucles while.
Ya es bastante malo cuando tienes las sentencias if en los bucles while.
Pero ahora, si tiene algo en lo que básicamente está en la línea 27 de su
código fuente y va a saltar a la línea 800 sin más razón que la palabra clave go to, de repente
se está saltando una tonelada de código, y es muy difícil de mantener y seguir.
Entonces, las dos partes a las que ir y el nombre de la etiqueta. El nombre de la
etiqueta sigue la misma convención para nombrar una variable, caracteres alfanuméricos, no puede
comenzar con dígitos, puede comenzar con guiones bajos.
puede comenzar con guiones bajos.
Básicamente, solo usa la palabra clave go to y va a algún
identificador, parte dos. La segunda parte es una etiqueta en alguna parte.
Entonces, para saltar realmente a esa línea de código, debe etiquetar esa línea de código.
Tiene que haber una declaración que diga la segunda parte.
Ahora te mostraré un ejemplo de esto, pero nunca deberías usarlo
debido a los problemas asociados con el mantenimiento.
Sin embargo, quería mencionarlo si programó antes y está acostumbrado a usarlo.
En c, realmente no es necesario usarlo tanto.
Hay un caso de uso que vi que podría ser útil.
Estaba trabajando el otro día con un compañero programador,
y él tenía un montón de bucles anidados
o declaraciones if anidadas.
Pero los bucles son probablemente el mejor ejemplo. Bucles, recuerde, código repetido. Tenía muchos bucles anidados.
Y en el bucle anidado muy interno, como el
quinto, quería saltar de todos los bucles porque tenía alguna condición.
Y así solía ir a saltar de todos esos bucles.
Ahora, la otra forma de saltar de los bucles es usar la palabra
clave de freno, pero el freno solo saldrá de lo más interno.
Entonces, realmente no había una forma efectiva sin que él estableciera un
montón de banderas y tuviera un montón de declaraciones if para salir de cada
bucle, así que solía ir a. Y ese fue un caso que pensé que
era bastante útil porque reducía la cantidad de código que tenías que escribir y era bastante claro lo que estaba sucediendo.
Simplemente saltaste de todos los bucles anidados porque
cumpliste una determinada condición.
Y ese es un caso. Pero en su mayor parte, realmente no necesitas ir
y, por las razones que mencioné, es muy problemático, es difícil seguir el código cuando estás saltando por todos lados.
Pero ir a es como lo usas como lo usas en otros idiomas.
Tiene una palabra clave ir a con el nombre de la etiqueta.
Y lo que sucederá en su código es que saltará a esa línea de código con la etiqueta.
Por lo que puede omitir todo tipo de código.
Entonces, en este ejemplo, tenemos una etiqueta llamada top y tiene
dos puntos. Así es como sabes que es una etiqueta.
Y top tiene algunas declaraciones. Y al final de
eso, tienes una declaración if. Y dices que si el carácter es igual a y, ve a la parte superior.
Entonces, nuevamente, ves cómo puedes saltar todo en tu código y eso hace que sea muy difícil de seguir.
Así que no lo use básicamente, a menos que tenga muchos, muchos, muchos bucles anidados y
quiera saltar de todos los bucles. Gracias.