Sentencias de control y bucles

Sentencia de control IF



Antes de empezar a explicar las sentencias de control del lenguaje C, conviene explicar los conceptos de verdadero/falso y de sentencia que posee el lenguaje C.
El lenguaje C posee un concepto muy amplio de lo que es verdadero. Para C, cualquier valor que sea distinto de cero es verdadero, siendo por tanto falso solo si el valor cero. Es por ello que una expresión del tipo if(x) será verdad siempre que el valor de la variable x sea distinto de cero, sea cual sea el tipo de la variable x.
El concepto de sentencia en C es igual que el de otros muchos lenguajes. Por sentencia se entiende en C cualquier instrucción simple o bien, cualquier conjunto de instrucciones simples que se encuentren encerradas entre los caracteres { y }, que marcan respectivamente el comienzo y el final de una sentencia.
La forma general de la sentencia if es:

if (condición)  
       sentencia; 
else   
        sentencia;

Siendo el else opcional. Si la condición es verdadera se ejecuta la sentencia asociada al if, en caso de que sea falsa la condición se ejecuta la sentencia asociada al else (si existe el else). Veamos algunos ejemplos de sentencias if:

int a,b;
if (a>b) 
{   
b--;   
a=a+5; 
} 
else 
{   
a++;  
 b=b-5; 
} 
if (b-a!=7)   
b=5;
 
Las sentencias de control if pueden ir anidadas. Un if anidado es una sentencia if que es el objeto de otro if o else. Esta anidación de if/else puede presentar la problemática de decidir que else va asociado a cada if. Considerese el siguiente ejemplo:

if (x)   
    if (y) printf(“1”);
   else printf(“2”);
 
¿A que if se refiere el else?. C soluciona este problema asociando cada else al if más cercano posible y que todavía no tiene ningún else asociado. Es por ello que en este caso el if asociado al else es el if(y). Si queremos que el else este asociado al if(x), deberíamos escribirlo de la siguiente forma:

if (x) 
{   
if (y)      
printf(“1”); 
} 
else   
printf(“2”);

Sentencia de control SWITCH


La forma general de la sentencia switch es:

switch(variable) 
{   
case const1:      
           sentencia;      
break;   
case const2:      
           sentencia;      
break;  
...   
default:      
       sentencia; 
}
Donde variable debe ser de tipo char o int, y donde const1, const2, ..., indican constantes de C del tipo de datos de la variable. Dichas constantes no pueden repetirse dentro del switch. 
El default es opcional y puede no aparecer, así como los break de los case. 
La sentencia switch se ejecuta comparando el valor de la variable con el valor de cada una de las constantes, realizando la comparación desde arriba hacia abajo. 
En caso de que se encuentre una constante cuyo valor coincida con el valor de la variable, se empieza a ejecutar las sentencias hasta encontrar una sentencia break. 
En caso de que no se encuentre ningún valor que coincida, se ejecuta el default (si existe). Veamos algunos ejemplos:

int valor; 
switch(valor) 
{   
case 0: cont++;           
break;   
case 5: cont--;           
break;   
default: 
cont=-10; /* Se ejecuta si valor no es 0 o 5 */ }
char d;



int cont=0; 
switch(d) 
{   
case ‘\r’: cont++; /* Si d es un retorno de carro, se */                      /* ejecuta este cont++ y el siguiente*/                     
 /* al no aparecer un break */  
 case ‘\x1B’: cont++;                
break;   
default: cont=-1; 
}
Las sentencias switch pueden aparecer unas dentro de otras, igual que sucedía con las sentencias if. Veámoslo con un ejemplo:

char d,e; 
switch(d) 
{   
case ‘a’:   
case ‘A’: 
switch(e)             
{                
case ‘1’: d=‘z’;                         
 e=‘+’;                          
break;                
case ‘2’: 
d=‘Z’;                         
e=‘-’;             
}             
break;  
 case ‘b’:   
case ‘B’: 
switch(e)            
 {               
 case ‘0’: d=‘2’;                
default: e=‘+’;            
 } }


Blucle For


La sintaxis del bucle for es:

for(inicialización,condición,incremento) sentencia;


En primer lugar, conviene destacar el hecho de la gran flexibilidad del bucle for de C. En C, el bucle for puede no contener inicialización, condición o incremento, o incluso pueden no existir dos e incluso las tres expresiones del bucle. El bucle for se ejecuta siempre que la condición sea verdadera, es por ello que puede llegar a no ejecutarse.


Veamos algunos ejemplos de bucles for:


int i,suma=0; 
for(i=1;i<=100;i++)   
suma=suma+i;
int i,j;
for(i=0,j=100;j>i;i++,j--) 
{   
printf(“%d\n”,j-i);   
printf(“%d\n”,i-j); 
}
float a=3e10; 
for(;a>2;
a=sqrt(a)) /* sqrt() calcula la raíz cuadrada */   
printf(“%f”,a);
char d; 
for(;getc(stdin)!=’\x1B’; 
/* Bucle que espera hasta que se */                            
/* pulsa la tecla Esc */
char d; 
for(;;) 
{   
d=getc(stdin);   
printf(“%c”,d);   
if (d==‘\x1B’)      
break; }


Como se observa en este último ejemplo, el bucle for no posee ninguna expresión. Para salir de el se usa la sentencia break, dicha sentencia (ya vista junto con la sentencia de control switch) se explicara mas detalladamente con posterioridad.


Bucle While

La sintaxis del bucle while es:

while (condición) sentencia;

Donde la sentencia puede no existir (sentencia vacía), pero siempre debe existir la condición. El bucle while se ejecuta mientras la condición sea verdad. 

Veamos algunos ejemplos de bucles while:
 


 

Conversión de tipos de datos

Conversión automática de tipos de datos

El lenguaje C permite que en una misma expresión aparezcan diferentes tipos de datos, encargándose el compilador de realizar las operaciones de forma correcta. El compilador del lenguaje C, cuando en una misma expresión aparecen dos o más tipos de datos, convierte todos los operandos al tipo del operando más grande existente de acuerdo con las dos reglas siguientes:

• Todos los char y short int se convierten a int. Todos los float a double.
• Para todo par de operandos, lo siguiente ocurre en secuencia: 
             o Si uno de los operandos es un long double, el otro se  convierte en long double. 
             o Si uno de los operandos es double, el otro se convierte a double. 
             o Si uno de los operandos es long, el otro se convierte a long. o Si uno de los operandos es unsigned, el otro se convierte a unsigned.
 
Después de que el compilador aplique estas reglas de conversión, cada par de operandos será del mismo tipo, y el resultado será del tipo de los operandos. Veamos un ejemplo:

char ch; 
int i; 
float f; 
double d;
 

(  ch  /  i  )  +  (  f  *  d  )  -  (  f  +  i  );   char   int        float double      float  int

Debido a que en la operación existen diferentes tipos se aplica la primera conversión:

ch de char pasa a int. f de float pasa a double.

(  ch  /  i  )  +  (  f  *  d  )  -  (  f  +  i  );   int    int       double double     double  int

Al ser los dos operandos de igual tipo, realizamos la primera operación, (ch / i), y el resultado es de tipo int. De igual forma, para la segunda operación, (f * d), y el resultado es de tipo double.

Para la tercera operación, y dado que las variables no son del mismo tipo, se aplica la segunda regla, convirtiéndose el int en double, realizándose la suma (f + i) como dos datos de tipo double, y siendo por tanto el resultado un double.

 

Ahora procedemos a realizar la suma de los dos primeros resultados (ch / i) + (f * d), como uno de ellos es de tipo int, y el otro de tipo double, el int se convierte en double por la segunda regla, y el resultado es un double.

Y por último, realizamos la resta final, siendo los dos operandos de tipo double y el resultado final, por tanto, de tipo double.

  

Conversión forzada de tipos datos

En C, existe, además, de la conversión automática de tipos de datos, la posibilidad de forzar la conversión de un tipo de datos en otro tipo de datos. Esta conversión de un tipo de datos en otro se llama “casts”, y su sintaxis es:

(tipo)expresión

Su utilidad queda claramente expresada en el ejemplo siguiente:

int a=3,b=2;

float c; 

c=a/b;

La operación asigna a c el valor 1.0 en vez de el valor 1.5, ello se debe a que al ser a y b variables de tipo entero, se realiza una división entre enteros, y el resultado de 3/2 es 1. A continuación ese valor 1 se convierte a un valor en coma flotante para realizar la asignación (valor 1.0), y se asigna a c. Si lo que se desea es que la división se realice en punto flotante, debe escribirse la operación de la siguiente forma:

c=(float)a/b;

Esta conversión forzada obliga a convertir la variable a en float, y entonces, aplicando las reglas de conversión automática de tipos, se realiza la división en coma flotante. Este proceso da lugar a que el resultado de la operación sea 1.5, y dicho valor sea el asignado a la variable c.