Lenguaje C

Estructuras de Control Selectivas

Conceptos previos
1) Expresión lógica
• En C, los valores de tipo caracter operan con tipo dual:
En contexto numérico (operadores aritméticos, formato %d), se convierten (cast) al entero = código ascii que les corresponde.
En contexto caracter (formato %c, funciones de caracteres, etc) operan como carácter.
Ejemplo:
char c = ‘A’; // código ascii 65
c = c+1; // código ascii 65 + 1 = 66, le corresponde ‘B’,
printf(“%c”, c); // imprime B

En modo recíproco, los números enteros entre 0 y 255 (valores ascii) también operan con tipo dual.

• En C no existe el tipo de dato booleano:

bool var; // error de compilación: no existe el tipo bool
Los valores de verdad y falso son sustituídos por los enteros 1 y 0 respectivamente.

Los operadores lógicos: ! (no), && (y) y || (o), en C no son lógicos; operan con números o caracteres y dan como resultado un nú-
mero, según las siguientes definiciones:
int m,n; char a, b;
0 si m es distinto de 0 !a = 0 si a es distinto de ‘\0’
!m = 1 si m es cero 0 1 si a = ‘\0’

1 si m y n son distintos de 0 a && b = 1 si a y b son distintos de ‘\0’

m && n =
0 si m o n es 0 0 si a o b es ‘\0’

m || n = 1 si m y/o n es distinto de 0 1 si a y/o b es distinto de ‘\0’

a || b =
0 si m y n son 0 0 si a y b son ‘\0’
También pueden operar con tipos de caracteres mezclados, ejemplo: si m = 6 y a = ‘b’
m && a → 1
El significado de las operaciones es el mismo que en lógica; pero ahora los operandos
son numéricos.

• Una expresión está formada por:

operandos: números, o caracteres convertidos a número.
operadores: aritméticos.
Ejemplos:
4
a
-a
a+b
a && b // a y b
a && b + c

• Condición verdadero falso: una expresión exp -de tipo numérico o caracter- se interpreta como verdad o falso dentro de
if(exp), ejm:
Si exp es de tipo numérico: Si exp es de tipo carácter:
v Si exp distinto de 0 v Si exp distinto de ‘\0’ = NULL
exp = exp = f Si exp = ‘\0’ = NULL
f Si exp = 0
Ejemplo:
int n = 5, m = 0; char a = ‘A’; b = ‘\0’;
if(n) // verdad
if(a) // verdad
if(b) // falso
if(n+a) // 5 + 65 = 70 → verdad

Los operadores se ejecutan en el siguiente orden de prioridad

1) Negación : !
2) Aritméticos: +, -, *, /, %
3) Relación : <, <=, == (igualdad), >, >=
4) Lógicos : && (and), || (or, tecla a la izquierda del 1)
5) Asignación: =
PÁGINA: 1
 Lenguaje C

Ejemplos:
int n = 1, m = 0, k;
if(0) evalúa a falso
if(1) evalúa a verdad
if() error de compilación
k = m || n evalúa a verdad y asigna 1 a k
k = m && n evalúa a falso y asigna 0 a k
if(m==0) evalúa a verdad
if(m=0) asigna 0 a m, luego procesa if(0) y evalúa a falso
if(m!=m) asigna falso(m distinto de m)
if(m=!m) !m == 1 (verdad); asigna m = 1; luego procesa if(1) y evalúa a verdad
if(m = m+4==3 || n-1>6 && 7 ||!6) Es una expresión que debe ejecutarse aplicando las reglas de prioridad
Preguntar si x pertenece al intervalo: <2, 4>
if(2 < x < 4) // es un error de compilación
if(2 < x && x < 4) // es correcto

Evaluar:
int m = 1, n = 2, k = 3, j = 5;
if(n = m == n-1 && 4 || k-j) printf("Hola\n");
Reemplazando valores se tiene:
if(n = 1 == 2-1 && 4 || 3-5) printf("Hola\n");
Aplicando las reglas de prioridad, la condición se ejecutá así:
n = 5 == 2-1 && 4 || 3-5 → n = 5 == 1 && 4 || -2 → n = 0 && 4 || -2 → n = 0 || -2 → n = 1 → asigna 1 a n
y evalúa a verdad
Salida:
Hola
Ejercicio: buscar en internet la tabla de prioridades de los operadores.

2) Notación:
Instruccion: Orden que ejecuta el sistema operativo, finaliza con “;” y comienza la siguiente, se recomienda escribir una instrucción
por línea; pero puede escribirse en más de una, o escribir varias instrucciones en una línea. El objetivo es doble:
1) Dar la orden al sistema operativo.
2) El conjunto de instrucciones debe facilitar al programador la comprensión de la lógica del programa, para ello se usan
indentaciones (con el tabulador), espacios en blanco, líneas en blanco, etc. Los espacios en blanco e indentaciones sólo lo ven
los humanos, el compilador los comprime, ejemplo:
scanf("%d", &n); // una sola instrucción
; // instrucció vacío
printf(“Ingrese un número entero”); scanf(“%d”, &n); // 2 instrucciones en una línea.

Bloque: Conjunto de 0 ó más instrucciones rodeadas por “{ }”; son muy importantes los espaciados en la escritura para dar claridad
“visual” al programa, ejemplo:
{ // inicio el bloque que contiene 2 instrucciones
printf("Ingrese el valor de n: "); // las instrucciones se indentan 1 tabulación
scanf("%d", &n); // esto es muy importante para percibir visualmente la lógica
} // fin de bloque
También se puede escribir:
if(2 < x && x < 4) { // inicio de bloque
printf(“2 < x ”); // 1 indentado
printf(“X < 4 ”);
} // fin de bloque

Otros bloques válidos son:

if(x) { ... } // contiene 0 instrucciones
if(x) {;} // contiene 1 instrucción vacía

BloqueInstruccion es un bloque o una instrucción

Estructuras de Control Selectivas

Una estructura de control selectiva es una instrucción compleja compuesta por:
Una condición de selección
bloqueInstruccion que se ejecuta de acuerdo al valor (verdad o falso) de la condición.
Hay 2 tipos de estructuras de control selectivas.

PÁGINA: 2
 Lenguaje C

Estructura selectiva simple (if)

Decide, de acuerdo a una condición, ejecutar un bloque o instrucción.

Sintaxis:
if (condición) bloqueInstruccionVerdad
[else bloqueInstruccionFalso] // atento: esta parte es opcional, está encerrada entre [ ]

Si la condición es verdadera se ejecuta el bloqueInstruccionVerdad; si es falsa se ejecuta el bloqueInstruccionFalso

Ejemplo: si asignamos n = 0 y preguntamos:

if(n==0) printf("Atento n ES 0"); // == es el operador relacional de igualdad
else printf("Atento n NO ES 0");
Salida: Atento n ES 0

Atento: Una estructura, como:

if(n==0) printf("Atento n ES 0");
else printf("Atento n NO ES 0");
Es una sola instrucción (compleja), no dos; aunque hayan 2 “;”

Ejemplo: si asignamos n = 5 y preguntamos:

if(n!=0) {
printf("n NO ES 0: \n");
printf("Todo va bien\n");
} // En este caso se usó un bloque de instrucciones para el if( ) y se omitió la parte else.
Salida:
n NO ES 0
Todo va bien

Diagrama de flujo

Ejercicio: Escribirá el programa el cual lee un número 0 ó

1 y lo escribe en letras:
0: cero
1: uno
01 // 02_01.c : Leer un número y decir si es par o impar
02 #include<stdio.h>
03 void main(void){
04 int n;
05 printf("Números\n");
06 printf("Escriba un número entero: ");
07 scanf("%d", &n); // Ingrese 4
08 if(n%2==0) printf("%d es par\n", n);
09 else printf("%d es impar\n", n);
10 }
Salida:
4 es par
Notas sobre la claridad del programa:
El objetivo principal es que la escritura del programa refleje “visualmente” la lógica del mismo, para esto siga las recomendaciones:
1) Los nombres de las variables deben ser nmemonicos, ni muy corta ni muy largas; deben seguir la notación camello, excepto para
constantes que van en mayúsculas.
2) Escribir una instrucción por programa; pero no es obligatorio.
3) Cada bloque indenta las instrucciones que contiene, inclusive en bloques anidados.
4) Enfatizar en la claridad, por ejemplo las líneas 08 y 09 tienen printf() alineados, esto facilita compararlos.
5) Las líneas 08 y 09 parecen dos instrucciones; pero son una sola instrucción (compleja) el if – else son parte de una instrucción.

Atento a la condición:
La condición es una expresión lógica, que puede ser desde muy sencilla a muy compleja, ejemplo:
if(0) ...; // 0 evalúa a falso, un número distinto de 0 evalúa a verdadero.
if(expresión compleja con operadores aritméticos, relacionales y lógicos) ...;
PÁGINA: 3
 Lenguaje C

Opcionalmente puede tener una asignación (=), ejemplo:

if(x=0) ...; // asigna 0 a x, luego evalúa if(0) …;
if(x= 2+1) … // opera 2 +1 → asigna 3 a x, luego evalúa if(3) …;

Ejemplo:
n = 1;
if(n) printf("Verdad\n");
else printf("Falso\n");
Salida:
Verdad

Atento a dos errores frecuentes:

1) El operador de igualdad es “==“; pero si se equivoca y escribe = (operador de asignación) obtendrá algo inesperado:
n = 6;
if(n=5) printf("Verdad\n"); // asigna 5 a n; finalmente pregunta if(5) ...
Salida:
Verdad

2) El operador de desigualdad es “!=“; pero si se equivoca y lo escribe al revés “=!“ obtendrá algo inesperado:
n = 6;
if(n=!5) printf("Verdad\n"); // evalua !5 y da 0 (falso), luego asigna 0 a n; finalmente pregunta if(0) ...
Salida: // No escribe nada.

3) Para expresar un intervalo en matemática escribimos: 4 <= n <= 8; queremos decir 4 <= n && n <= 8
Podemos escribir de las dos formas y compila; pero no es lo mismo al ejecutar:
If(2 <= 3 <= 2) // compila y ejecuta if(1 <= 2) → 1
If(2 <= 3 && 3 <= 2) // compila y ejecuta if( 1 && 0) → 0

Ejemplo:
Inicio // 02_02.c: Leer 4 números i, j, k y m; encontrar el mínimo. Hay varias formas de hacerlo, acá van 4 sabores:
#include<stdio.h>
void main(void){
int i, j, k, m, min;
printf("Ingrese 4 números enteros: ");
scanf("%d %d %d %d", &i, &j, &k, &m); // ingrese: 8, 5, 1, 7
min = i; if(i < j) min = i; min = (i < j)? i:j;
else min = j;
Proceso if(min > j ) min = j; if(i > j) i = j;
if(min > k ) min = k; if(min > k ) min = k; if(min > k ) min = k; if(i > k) i = k;
if(min > m) min = m; if(min > m) min = m; if(min > m) min = m; if(i > m) i = m;
Fin printf("El mínimo es: %d \n", min); printf("El mínimo es: %d \n", i);
} }
Salida:
Ingrese 4 números enteros: 8, 5, 1, 7
El mínimo es: 1
Observe los 3 pasos en que se dividen frecuentemente los procesos.

Un viejo truco
El siguiente if:
if(cond1 && cond2 && cond3 ….) bloqueInstruccionVerdad

Es equivalente a:
if(cond1)
if(cond2)
if(cond3)
if(cond...) bloqueInstruccionVerdad
Esta segunda forma se usa cuando es complicado calcular cond1, cond2, …. por ejemplo cuando se valida varios datos:
if(validar1(dato1)) // si hay error en el dato 1 se reporta
if(validar2(dato2)) // si hay error en el dato 2 se reporta
if(validar3(dato3)) //…...
if(valid... ) printf("Todos los datos fueron ingresados correctamente");

PÁGINA: 4
 Lenguaje C
Operador ternario:
Supongamos que tenemos el código:
int m = 3, n;
if (m==3) n = 1;
else n = 2;

La instrucción if/else anterior es muy frecuente, por tal motivo tiene un atajo:
int m = 3, n;
n = (m==3) ? 1 : 2; // operador ternario, con dos operadores y tres operandos.

La sintaxis general de un operador ternario (el cual tiene dos operadores y tres operandos) es:

n = (condición) ? valorTrue : valorFalse;

Si condición es verdadera: n = valorTrue

caso contrario : n = valorFalse;

Anidamiento: una instrucción if puede contener (anidar) otros if; ejemplo:

if(n==0)
if (m == 0 ) printf("n = 0 y m = 0");
else printf("n = 0 y m != 0");
else
if (m == 4 ) printf("n ¡= 0 y m = 4");
else printf("n != 0 y m != 4");

Indente las instrucciones con claridad, personalmente yo prefiero:

• Alinear los bloques de modo que permita verificar la lógica del programa a golpe de vista
• No use { } si no es necesario; atento a las llaves cuando quita o aumenta instrucciones.

// 02_03.c : Leer 3 números y escribirlos en orden ascendente

#include<stdio.h>
void main(void){
int i, j, k;
printf("Ingrese 3 enteros: ");
scanf("%d %d %d", &i, &j, &k);
if(i <= j && i <= k){ printf("Menor: %d\n", i);
if(j <= k){ printf("Medio: %d\n", j);
printf("Mayor: %d\n", k);
} else { printf("Medio: %d\n", k);
printf("Mayor: %d\n", j);
}
} else if(j <= k){ printf("Menor: %d\n", j);
if(i <= k){ printf("Medio: %d\n", i);
printf("Mayor: %d\n", k);
} else { printf("Medio: %d\n", k);
printf("Mayor: %d\n", i);
}
} else{ printf("Menor: %d\n", k);
if(i <= j){ printf("Medio: %d\n", i);
printf("Mayor: %d\n", j);
} else { printf("Medio: %d\n", j);
printf("Mayor: %d\n", i);
}
}
}

Este es un ejemplo de anidamiento múltiple, en el que se puede apreciar visualmente la lógica, y verificar y comparar los detalles con
facilidad:
• Las condiciones lógicas: if(exp lógica) { ... } else { ... } que forman una jerarquía de anidamientos.
• Apertura y cierre de las llaves que forman bloques
• El contenido de los bloques, observe y compare los 3 bloques de printf()

PÁGINA: 5
 Lenguaje C
Ejercicio: Escriba el programa numeros.c; el cual lee un número entre 0 y 5 y lo escribe en letras:
0: cero
1: uno
…..

Este ejercicio lo podemos programar utilizando la sentencia if … else en modo anidado; pero sería muy engorroso; Será más fácil utilizar
otra estructura de decisión.

Estructura selectiva múltiple (switch)

Decide, de acuerdo al valor de una expresion, ejecutar bloqueintrucciones.
Sintaxis:
switch(expresion) {
case valor1: bloqueInstruccion1 // si valor1, se ejecuta bloqueInstrucción1 y
// continúa al bloqueInstrucción2
case valor2: bloqueInstruccion2 // si valor2, se ejecuta bloqueInstrucción2 y
// continúa al bloqueInstrucción3
...
case valorN: bloqueInstruccionN // si valorN, se ejecuta bloqueInstrucciónN y
// continúa a default, si existe, si no finaliza
[default: bloqueInstruccionDefault] // si no coincide con valores, se ejecuta bloqueInstruccionDefault
}

Diagrama de flujo

Ejercicio: Escribirá el programa numeros.c; el cual lee un número entre 0 y 3 y lo escribe en letras:
0: cero
1: uno
…..
// 02_04a.c : Uso de switch: Escribir número en letras
#include<stdio.h>
void main(void){
int n;
printf("Escriba un entero: ");
scanf("%d", &n); // tipee 2
switch(n) {
case 1: printf("uno\n");
case 2: printf("dos\n");
case 3: printf("tres\n");
default: printf("fuera de valor\n");
}
}

Salida:
dos
tres
fuera de valor // Esta salida cumple las reglas de la sintaxis; pero no resuelve el problema planteado; la solución es poner un
// break; al finan de cada bloqueInstrucción de los case:

PÁGINA: 6
 Lenguaje C

// 02_04b.c : Uso de switch: Escribir número en letras

#include<stdio.h>
void main(void){
int n;
printf("Escriba un entero: ");
scanf("%d", &n); // tipee 2
switch(n) {
case 1: printf("uno\n"); break; // break: Salta al fin del switch
case 2: printf("dos\n"); break; // break: Salta al fin del switch
case 3: printf("tres\n"); break; // break: Salta al fin del switch
default: printf("Fuera de valor\n");
}
}
Salida:
dos

Es el resultado que necesitamos; si hiciéramos n = 4; la salida sería:

Salida:
Fuera de valor.

Los break obligan a que se ejecute solo el bloqueInstruccion correspondiente al case; si no se cumple ningún case, se ejecuta el
bloqueInstruccionDefault.

Anidamiento: Ahora podemos hacer varios tipos de anidamiento de instrucciones de decisión, por ejemplo:
If(n >= 0) {
switch(n) {…}
} else if(…) {…}
else ….
Sea cuidadoso al usar { }, tanto para agrupar/desagrupar instrucciones, como para aclarar la lógica.

Ejercicio: Escriba un programa que lea un número n entero y haga lo siguiente:

si n está entre 0 y 5, escriba su valor en letras.
En caso contrario:
si n < 0, que escriba: n debe ser >= 0
en caso contrario, que escriba: n es muy grande.

Ejemplo: Este ejercicio ya fue presentado en el capítulo anterior, ahora lo modificaremos para presentar más opciones.
Escriba un programa que lea dos enteros m n mayores que 0, luego presente el menú:
Calculadora:
1) Sumar: m + n
2) Restar: m – n
3) Multiplicar: m * n
4) Dividir: m/n
Elija la operación: _
Ejecute la opción seleccionada.

// 02_05.c : Leer dos enteros m n mayores que 0, presentar un menú y ejecutar la operación seleccionada
#include<stdio.h>
void main(void){
int m, n, op;
printf("Ingrese un entero m = "); scanf("%d",&m);
printf("Ingrese un entero n = "); scanf("%d",&n);
printf("\nOperación que requiere:\n");
printf("1) Sumar: m + n\n");
printf("2) Restar: m – n\n");
printf("3) Multiplicar: m * n\n");
printf("4) Dividir: m/n\n");
printf(" Elija su opción: "); scanf("%d",&op);
switch(op){ // Selección de opción
case 1: printf("suma = %d\n", m+n); break;
case 2: printf("Resta = %d\n", m-n); break;
case 3: printf("Multiplicación = %d\n", m*n); break;

PÁGINA: 7
 Lenguaje C
case 4: if(n==0) printf("Denominador 0\n");
else if(m%n==0) printf("División = %d\n", m/n);
else printf("División = %.2f\n", (float)m/n);
break;
default: printf("Opción errada\n");
}
}

Salida:

Atento:
• Usar las indentaciones correctas "visualiza" la lógica
• Fíjese que se ha violado la recomendación de escribir una instrucción por línea, por ejemplo:
case 2: printf("Resta = %d\n", m-n); break;
Esto se hizo para visualizar mejor la lógica.

Matriz de casos prueba:

Caso Entradas Salida Chequeo
m n opción
1 3 2 1 5 √
2 3 2 2 1 √
3 3 2 3 6 √
4 3 2 4 1.50 √
5 4 2 4 2 √
6 2 0 4 Denominador 0 √
7 7 Opción errada √

Ejercicios: Escriba, compile y ejecute programas que hagan lo siguiente:

1) Lea dos enteros j, k y calcule m de dos modos:
a) if(j < k) m = a;
else m = b;
b) m = (j < k)? a:b;
¿Hay alguna diferencia?

2) Pida tres números y muestre el menor y mayor de ellos.

3) Lea un entero n entre 1 y 3500 y escriba su equivalente en números romanos, sugerencia: busque el programa en internet.

4) Un estudiante ha dado 3 prácticas y obtuvo 16, 17 y 13, en base 20. La cuarta práctica debe cumplir: 1) Ser la máxima posible y 2)
El promedio de las 4 prácticas debe ser entero.

PÁGINA: 8