Los Ciclos, también llamados Bucles, son unas sentencias de control -que nos permiten manipular el flujo del programas- utilizadas para la ejecución repetitiva de instrucciones; para ello se valen de una “Condición de parada” y, de acuerdo a nuestras necesidades, podemos utilizar una u otra, muchas veces, en instrucciones sencillas, no importa demasiado, pero en programas más amplios es necesario escogerlas con cuidado.
Ciclo While
Como su traducción literal lo indica, la utilizamos para repetir acciones “mientras” la condición que le indiquemos sea verdadera -que nos de un ‘1’ por la operación lógica-, si la condición se cumple, se entra al ciclo, y este se repetirá mientras la condición sea verdadera, si durante el ciclo -por operaciones y demás- la condición deja de ser verdadera o se encuentra con un “break;” -como el del switch-, se sale del ciclo y el código que sigue fuera de él se ejecutará normalmente, su sintaxis es:
while(condición){Sentencias;}
Cabe mencionar que los corchetes son opcionales, si no se usan, significa que el while abarca “una línea”, esto es, únicamente busca “sentencia;”, no importando si está al lado, abajo o veinte líneas en blanco abajo en nuestro código porque el complador borá todo eso y lo que le importa es que el fin de línea que significa una sentencia se dé con “;”, por eso es tan imporante. Los corchetes nos permiten hacer “un bloque” de código, un “ámbito“, por eso TODO lo de main va entre corchetes y cuando hagamos funciones, también los usaremos.
Click en la Imagen para Ampliar
Click en la Imagen para Ampliar
Analizemos, mientras que i sea igual a 0 se ejecuta la siguiente línea, o sea, el print en la línea 6, la línea 7 es también para el compilador otra sentencia, escribirlo así es para que nosotros lo leamos mejor, por eso ya no se ejecuta, el programa no necesita getch porque jamás se va a detener, como a i no le estamos haciendo nada, siempre va a valer 0, y la expresión “i==0” siempre nos dará un true -1-, es equivalente a escribir:
while(1){Sentencias;}//while(true) lo leo yo por comodidad, pero TRUE -mayúsculas- es una constante “definida” en stdio, me parece, también el while(1) se puede cambiar por while(TRUE)
Do-While
El primo de While, o su prima libertina -XD-. Al igual que while, requiere una condición, pero permite entrar al ámbito del ciclo aún si no se ha complido dicha condición. Primero entra, ejecuta todo el código en el ámbito del do-while, después checa la condición lógica y si es cierta, sigue ejecutando el código hasta que ésta sea falsa y por ende se detenga. Veamos:
Click en la Imagen para Ampliar
Nos entrega:
Click en la Imagen para Ampliar
Ahí se ve lo que ocurre con el do-while, primero entra, imprime, aumenta 10 al valor de i, después verifica la condición y decide si se ejecuta de nuevo o no. Al principio, i vale 10, se imprime, se aumenta y cuando checa la condición, ve que i<100 es cierta y lo hace de nuevo, ¿por qué solo imprime del 10 al 90? Porque primero se imprime y luego se hace el aumento, entonces, i va cambiando así:
Ciclo|valor de i al acabar
1|20
2|30
3|40
4|50
5|60
6|70
7|80
8|90
9|100
Ya se llegó a que i valga 100, pero eso se imprimiría en la siguiente instrucción, i ya lo vale, sale del ciclo y, como corroboramos, su valor es de 100. Ahora, ejecutamos las mismas instrucciones -pff se ahorra tiempo con funciones-, exáctamente las mismas, se imprime 100, se checa la condición y… momento ¿por qué se imprimió si el ciclo anterior había dicho que ya no podía ejecutarse el código y decidió parar? Porque, al contrario del While, el do-while permite que se entre al menos una vez al bloque de código y después verifica si se ha de ejecutar una siguiente vez. Usar while y do-while es una desición que se debe tomar con cuidado.
Ciclo For
El favorito de muchos, este ciclo es tremendamente utilizado para lo que tiene que ver con Arreglos, especialmente matrices, pues anidarlo -usar uno dentro de otro, como vimos con los ifs- es más sencillo de entender que anidar whiles o do-whiles para ese tipo de acciones. Lo que hace el for es tener una variable “contadora” que es la que nos indica la condición de parada, también se pueden ocupar 2 -no sé si más-, pero eso lo veremos luego con ejemplos. Su sintaxis es:
for(contador;condición(es);acciones al finalizar el ciclo){Sentencias}
Las condiciones al finalizar el ciclo suelen ser incrementos o decrementos. Muchos se preguntan el por qué se coloca casi de cajón una variable llamada ‘i’ como contador, en toda la web y hasta en mis ejemplos, ocupamos mucho la i para ciclos, no lo sé a ciencia cierta, pero creo que tiene que ver con que cada ciclo es también llamado “iteración”, y se toma su inicial, recordemos que C es un lenguaje imperativo, que se basa en la utilización de sentencias de control de flujo y ciclos iterativos -entre otras cosas- para resolver sus problemas.
En algunos lenguajes es posible declarar nuestro contador dentro del ciclo:
for(int i = 0;i<100,i+=10) //Ejemplo que no se puede en C
Nosotros debemos declarar en el mismo ámbito la variable que deseamos usar como contador y ya que estemos dentro del ciclo, darle un valor inicial:
int i = 0;
for(i=0;i<100;i++) //Esto sí se puede hacer
Vamos con un ejemplo, escribiremos los números del 1 al 10 con un ciclo for:
Click en la Imagen para Ampliar
Nos entrega:
Click en la Imagen para Ampliar
Siempre hay muchas formas de hacer lo mismo, unas más eficientes que otras, algunas más cómodas, otras más sencillas de leer, es un ejemplo de cómo podemos explotar nuestra imaginación, tal vez pongo mucho de mi idiosincracia en cómo estoy haciendo el tutorial, casi siempre hago los códigos como yo sé hacerlos, siempre con corchetes en los cilclos for aunque sean de una línea y cosas así, pero trataré de explorar las diferentes formas que sé de ahora en adelante.
Muy común es lo que vimos cuando usé j, necesitamos decir “Iteración [1]: ” y cosas así, ocupamos un entero, pero bien puede ser que si i es nuestro contador, en lugar de ir ‘de 0 a 9’ o algo así, que vaya de 100 a 40, no sé, que en lugar de decirle en la condición i<número le digamos i<variable, muchas cosas podemos hacer con ello, luego mostraré como incluír a j dentro de las instrucciones del diclo para ahorrarnos unas líneas y que el código sea más bonito y cómodo; así como funciona el for para una línea puede funcionar el while, para que quien lo desee, practique. También, se pueden poner más de una condición, con && y ||, los and y or lógicos que ya hemos visto antes, esto es especialmente útil para métodos numéricos, por ejemplo, y otro tipo de problemas que requieren este tipo de condiciones:
while(temperatura<maxima&&capacidad>almacenado){
sentencias;sentencias;sentencias;}
Espero no haberme explayado demasiado escribiendo cosas que no son de interés para quien lea esto, varios días no escribí, pero así es la cosa, a veces no dan tantas ganas, de momento es todo, ya casi se acaba lo más básico de C, faltan Funciones, Arreglos, Punteros-aunque eso ya es más avanzado- y ps si C es lenguaje estructurado es porque podemos hacer Estructuras, pero eso se entenderá a su tiempo. Saludos
SENTENCIAS DE CONTROL EN C
Se recomienda evitar la utilización de este ultimo tipo de sentencias.
C.1 Sentencias condicionales
Hay tres sentencias condicionales en C: if, else y switch
C.1.1 Sentencia if
La sentencia if nos permite elegir si se ejecuta o no un bloque de
instrucciones. La "expresión" del if es una expresión que debe ser
evaluada: falsa si es cero y verdadera si vale distinto de cero.
Ejemplo:
#include <stdio.h>
int main ()
{
int x;
printf(“Dame un numero”);
scanf(“%d”,&x);
if (x>0) {
printf(“El numero %d es positivo”,x);
}
return 0;
}
C.1.2 Sentencia else
Una sentencia if cuando incluye un else, permite ejecutar un bloque de
código si se cumple la condición y otro bloque diferente de código si la
condición no se cumple.
Ejemplo:
#include <stdio.h>
void main ()
{
int x;
printf(“Dame un numero: ”);
scanf(“%d”,&x);
if (x>=0) {
printf(“El numero %d es positivo”, x);
} else {
printf(“El numero %d es negativo”, x);
}
}
C.1.3 Sentencia else colgante
Ejemplo:
#include<stdlib.h>
int main()
{
float nota;
printf ("Dame una nota: ")
scanf ("%f", ¬a)
if (nota>9){
printf("Sobresaliente");}
else if(nota >=7){
printf("Notable);}
else if(nota >=5){
printf("Aprobado");}
else{
printf ("Suspenso);}
return 0;
}
C.1.4 Sentencia switch
Permite seleccionar entre multiples alternativas posibles. La expresión
del switch es una variable int o char, que puede tomar los valores,
entre otros, dados por "opción 1", "opcion 2", etc.
Ejemplo:
#include <stdio.h>
void main()
{
int nota;
printf(“Calificación: ”);
scanf(“%d”, ¬a);
switch (nota) {
case 0:
case 1:
case 2:
case 3:
case 4:
printf(“Suspenso”);
break;
case 5:
case 6:
printf(“Aprobado”);
break;
case 7:
case 8:
printf(“Notable”);
break;
case 9:
printf(“Sobresaliente”);
break;
case 10:
printf(“Matrícula”);
break;
default:
printf(“Error”);
}
}
C.2 Sentencias de control: Iteración
Las instrucciones de iteración también llamados bucles, se ejecutan
hasta que se cumpla alguna condición predeterminada en el bucle en el
caso del “for” o también en los casos del “while” y “do-while”. Podemos
destacar los antes mencionados bucles que son los bucles for,while y
do-while.
C.2.1 Bucles for:
Tienen una gran potencia y flexibilidad, y tienen un esquema muy sencillo y definido. Este esquema es así:
for(inicialización del bucle; condición; incremento).
Ahora vamos a proceder a definir cada una de las partes del esquema
básico, inicialización (exp1): es una asignación que se utiliza para
comenzar la variable del bucle, esto es de la variable de la que parte
el bucle. Condición (exp2): es una expresión relacional que hace que el
bucle concluya cuando no se cumpla. Por último el incremento (exp3): es
la parte que determina como cambia la variable hasta que el bucle
concluye. Es importante señalar que cada parte ha de ser separado por ;
.Para que deje de ejecutarse el bucle como antes hemos mencionado
depende de la condición, que deberá de ser falsa para que el bucle se
detenga.
Debemos tener en cuenta que a diferencia de otros bucles este no llegará
a ejecutarse si la condición es falsa, ya que la condición se comprueba
antes de entrar en el bucle.
Un sencillo ejemplo:
#include <stdio.h>
int main( )
{
int x;
for(x=1; x<=100; x++)
printf (“%d”,x);
return 0;
}
Una de las utilidades del bucle for es en el bucle infinito, que pese a
que puede hacerse con todos los bucles es el for con el que se usa.
Estos bucles infinitos son usados para que el bucle no concluya nunca
hasta que en el cuerpo se encuentre un break. Por otro lado la
construcción de este bucle for es muy sencilla, for ( ; ; ).
C.2.2 Bucles while:
Tiene cierta semejanza con el bucle for, así es en el uso de una
inicialización, una condición y un incremento. Otra de sus similitudes
es el momento en el que analizan la condición que en ambos es antes de
ejecutar el bucle. Sin embargo, en su esquema básico aunque parezcan
diferentes, son el mismo:
while (condición)
{
cuerpo;
incremento;
}
Algunas de las veces podremos saber antes de empezar el bucle cuantas veces se va a ejecutar.
Ejemplo:
char esperar_caracter (void)
{
char c;
c=’\0’;
while (c!=’A’)
c=getchar ( );
return c;
}
C.2.3 Bucles do-while:
Este es el único bucle que al menos se va a ejecutar una vez puesto que
este bucle examina la condición una vez se ha ejecutado el bucle, esto
es, al final del mismo. El esquema básico de este bucle sería algo así:
do
{
cuerpo;
}
while (condición);
Este bucle es muy útil por ejemplo en menús dado que el menú debe de ejecutarse al menos una vez.
Ejemplo:
#include <stdio.h>
int main()
{
int digito=0;
do {
printf("%d ",digito++);
}
while (digito<=9);
}
C.3 Sentencias de salto
Hay cuatro sentencias de salto en C: break, return, goto y continue.
Suelen estar condicionadas (que solo las ejecute el programa en un determinado caso).
Se desaconseja la utilización de este tipo de sentencia de control,
sobre todo el goto, ya que su uso implica un aumento de la probabilidad
de cometer errores, dificulta la legibilidad del código y es mucho mas
difícil corregir errores y cambiar secuencias de código.
C.3.1 Sentencia break
La instrucción de salto break se usa para interrumpir (romper) la
ejecución normal de un bucle, es decir, la instrucción break finaliza la
ejecución de un bucle y, por tanto, el control del programa se
transfiere (salta) a la primera instrucción después del bucle.
Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
break;
/* En el caso de que n sea un cero,
el bucle se interrumpe. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );
printf( "Suma: %d", a );
return 0;
}
C.3.2 Sentencia return
La instrucción de salto return es utilizada en lenguaje C para devolver
el control de ejecución desde la función que contiene el return a la
rutina que la invocó y para indicar el valor de retorno de una función.
Ejemplo:
#include <iostream>
int z;
void funcion();
int main()
{
for(z=0;z<=5;z++)
{
printf("%i\n",z);
funcion();
system("pause");
}
return 0; Indica al ordenador que el programa ha fnalizado sin errores.
}
void funcion()
{
printf("Hola\n");
if(z==3){printf("Z vale 3\n"); return;} El return termina la función y entonces printf("Z no vale 3\n"); no se ejecutará
printf("Z no vale 3\n");
}
C.3.3 Sentencia goto
La instrucción de salto goto se puede usar en un programa, para
transferir incondicionalmente el control del mismo a la primera
instrucción después de una etiqueta, o dicho de otra forma, al ejecutar
una instrucción goto, el control del programa se transfiere (salta) a la
primera instrucción después de una etiqueta.
Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
goto etiqueta_1;
/* En el caso de que n sea un cero,
el control de programa salta a la
primera instrucción después de
etiqueta_1. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );
etiqueta_1:
printf( "Suma: %d", a );
return 0;
}
C.3.4 Sentencia continue
La instrucción de salto continue siempre se usa para interrumpir
(romper) la ejecución normal de un bucle. Sin embargo, el control del
programa no se transfiere a la primera instrucción después del bucle,
como sí hace la instrucción break, es decir, el bucle no finaliza, sino
que, finaliza la iteración en curso, transfiriéndose el control del
programa a la condición de incremento de contadores y después a la
condición de salida del bucle, para decidir si se debe realizar una
nueva iteración o no.
Ejemplo:
#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.\n" );
continue;
/* En el caso de que n sea un cero,
la iteración en curso del bucle
se interrumpe aquí. */
}
printf( "El opuesto es: %d\n", -n );
a += n;
} while ( n >= -10 && n <= 10 );
printf( "Suma: %d", a );
return 0;
}
