Ciclo while

El ciclo while se repite la cantidad de veces que se repite la condición.

Sintaxis:

while(condición){

     //  instrucciones

}

Ejemplo 1: Imprimir números del 1 al 20.

Si queremos mostrar en pantalla los números del 1 al 20 podríamos hacer lo siguiente:

//*********************************************************************
#include <stdio.h>
int main(){
    printf("\n1");
    printf("\n2");
    printf("\n3");
    printf("\n4");
    printf("\n5");
    printf("\n6");
    printf("\n7");
    printf("\n8");
    printf("\n9");
    printf("\n10");
    printf("\n11");
    printf("\n12");
    printf("\n13");
    printf("\n14");
    printf("\n15");
    printf("\n16");
    printf("\n17");
    printf("\n18");
    printf("\n19");
    printf("\n20");
    return 0;
}
//*********************************************************************

Estaríamos repitiendo 20 veces la función printf. También podriamos imprimir todo solo en una línea, de la siguiente forma:

//*********************************************************************
#include <stdio.h>
int main(){
    printf("\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20");
    return 0;
}
//*********************************************************************

El resultado será el mismo, pero en caso de querer modificar la cantidad habría que agregar manualmente más números o por el contrario quitarlos.

Salida:

En este caso sería muy útil usar el ciclo while:

//*********************************************************************
 #include <stdio.h>
int main(){
    int n=1;
    while(n<=20){
        printf("\n%d",n);
        n++;
    }
    return 0;
}
//*********************************************************************

Se declara una variable n con un valor inicial de 1, luego se escribe el ciclo while cuya condición será: que se repita la instrucción mientras la variable sea menor a 20, y la instrucción que va a mostrar es la impresión de la variable. Seguidamente hay un contador que va a modificar el valor de la variable.

La salida es la siguiente:

En caso de olvidar colocar el contador o modificar la variable, la instrucción se repetirá constantemente. Asi:

//*********************************************************************
 #include <stdio.h>
int main(){
    int n=1;
    while(n<=20){
        printf("\n%d",n);
    }
    return 0;
}
//********************************************************************* 
La salida seria la siguiente:

La condición siempre se va a cumplir.

Ciclo For

El ciclo for, permite repetir la información que se le indique, la cantidad de veces que una condición se cumpla.

Sintaxis:

for(inicialización,condición,contador){

    //instrucciones a repetir

}

*Inicialización, se inicializa una variable.

*Condición, se escribe la condición que se debe cumplir para que se ejecuten las instrucciones que estan entre las llaves.

*Contador, modificara la variable que se inicializo.

Ejemplo 1: Ciclo for incrementando.

//*********************************************************************

#include <stdio.h>

int main(){

    int var;

    for(var=0;var<5;var++){

        printf("\nVuelta %d",var);

    }

    return 0;

}

//*********************************************************************

Se declara una variable y luego el for, donde la variable es inicializada en 0 y se dice que si var (0) es menor que 5 se ejecute la linea de codigo que muestra un mensaje en pantalla.

* Como se cumple, el mensaje se muestra y la variable incrementa en una unidad, ahora vale 1.

* Se vuelve a revisar en la linea de for y se compara, como nuevamente se cumple, se muestra el mensaje y vuelve a incrementar.

* Continua en la linea de for, var ahora vale 2. Seguidamente se cumple nuevamente la condición y ahora var vale 3.

* Se vuelve a evaluar la linea de for y como se cumple se vuelve a imprimir el mensaje en pantalla y ahora var vale 4.

* Nuevamente se cumple la condición, var vuelve a incrementar y vale 5, pero ahora al volver a la línea de for cuando se evalué la condicion 5<5, no se cumplirá así que no se volverán a ejecutar las instrucciones del for

Nota: para este ejemplo como el bloque de instrucciones del ciclo for tiene solo una línea, no es necesario colocar las llaves.

Salida:

Ejemplo 2: Ciclo for decrementando.

//*********************************************************************

#include <stdio.h>

int main(){

    int var;

    for(var=5;var>0;var--){

        printf("\nVuelta %d",var);

    }

    return 0;

}

//*********************************************************************

El mismo ejemplo pero esta vez decrementando.

Salida:

Ejemplo: Ciclo for para registrar datos de varias personas.

//*********************************************************************

#include <stdio.h>

int main(){

    int var,cant,edad;

    char nombre[20],apellido[20],direccion[40];

    printf("\nCantidad de personas que va a registrar.");

    scanf("%d",&cant);

    for(var=0;var<cant;var++){

        printf("Persona %d:",var+1);

        printf("\n\tNombre: ");

        fflush(stdin);

        gets(nombre);

        printf("\n\tApellido: ");

        fflush(stdin);

        gets(apellido);

        printf("\n\tDireccion: ");

        fflush(stdin);

        gets(direccion);

        printf("\n\tEdad: ");

        scanf("%d",&edad);

    }

    return 0;

}

//*********************************************************************

En este caso el usuario indicará la cantidad de personas que van a registrarse, se esta manera no será necesario escribir varias veces las líneas en las que se piden los datos de las personas.

Salida:

Condicional Switch

Switch es usado para situaciones con varias posibilidades.
La sintaxis es:

switch(variable){
    case 'opcion1':
    //instrucciones
    break
    case 'opcion2':
    //instrucciones
    break
    default:
}

Si no se coloca break al finalizar las instrucciones de cada case el programa ejecutará las instrucciones de todos los case que esten después de la que se cumpla.
default se coloca para el caso en que no se cumpla ninguno de los case.

Ejemplo 1: Uso de switch con números.
//*********************************************************************
#include <stdio.h>
int main(){
    int num;
    printf("Ingrese un numero: ");
    scanf("%d",&num);
    switch(num){
        case 1:
            printf("\nNumero 1.");
            break;
        case 2:
            printf("\nNumero 2.");
            break;
        case 3:
            printf("\nNumero 3.");
            break;
        default:
            printf("\nNinguna de las opciones posibles");
    }
    return 0;
}
//*********************************************************************

Salida:

 Ingresando 1.

Ingresando 2.

Ingresando 3.

 

 Ingresando 4.

 

 Ejemplo 2: Uso de switch con simbolos.
//*********************************************************************
#include <stdio.h>
int main(){
    char letra;
    printf("Ingrese una letra: ");
    scanf("%c",&letra);
    switch(letra){
        case 'a':
            printf("\n Vocal a.");
            break;
        case 'e':
            printf("\n Vocal e.");
            break;
        case 'i':
            printf("\n Vocal i.");
            break;
        case 'o':
            printf("\n Vocal o.");
            break;
        case 'u':
            printf("\n Vocal u.");
            break;
        default:
            printf("\nLa letra que ingreso no es vocal");
    }
    return 0;
}
//*********************************************************************

Salida:
Ingresando a:

 

Ingresando e:

Ingresando w:

Condicional If

La estructura condicional if (si), permite que en caso de que se cumpla una condición se ejecute una serie de instrucciones.

Sintaxis:
if( condicion ){
    /* Instrucciones a ejecutar en caso de que se cumpla la condicion */
}

Por ejemplo: Pedimos la edad de una persona y en caso de que sea menor de 18 años se debe imprimir un mensaje.
//*********************************************************************
#include <stdio.h>
int main(){
    int edad;
    printf("Ingrese su edad: ");
    scanf("%d",&edad);
    if(edad < 18){
        printf("\nAun eres menor de edad.");
    }
    printf("\nFin de la ejecucion");
    return 0;
}
//*********************************************************************

Como entre llaves solo hay una linea de codigo no es necesario colocar las llaves, asi que si se escribe de la siguiente forma debe tener la misma salida:
//*********************************************************************
#include <stdio.h>
int main(){
    int edad;
    printf("Ingrese su edad: ");
    scanf("%d",&edad);
    if(edad < 18)
        printf("\nAun eres menor de edad.");
    printf("\nFin de la ejecucion");   
    return 0;
}
//*********************************************************************

Nota: En la condición de if se hace uso de los operadores de relaciones para comparar.
Salida:

En caso de que sea menor a 18:

En caso de que sea mayor a 18:

Otro ejemplo: Pedir al usuario un número y mostrar un mensaje diciendo si es negativo o positivo y par o impar.

//*********************************************************************

#include <stdio.h> int main(){

    int num;

    printf("Ingrese un numero: ");

    scanf("%d",&num);

    if(num < 0){

        printf("\nEl numero es negativo");

    }

    if(num > 0)

        printf("\nEl numero es positivo");

    if( (num%2) == 0 )

        printf("\nEl numero es par");

    if( (num%2) != 0 )

        printf("\nEl numero es impar");   

    return 0;

}

//*********************************************************************

En este caso se presentan varias condiciones, primero se ingresa un numero y luego se compara en las primeras dos condiciones si es positivo o negativo y en las siguientes si es par o impar.

Nota: En la condición de if se hace uso de los operadores de relaciones para comparar.

Estas lineas de codigo pueden reducirse haciendo uso de la palabra reservada else.

Usamos else cuando estamos comparando una misma situacion. Por ejemplo cuando verificamos que el numero sea positivo o negativo, se puede indicar:

 Si num es menor que 0 muestre un mensaje y en caso de lo contrario (o en caso de que no se cumpla la condicion anterior), ejecute la siguiente.

A continuacion se podra visualizar mejor:

//*********************************************************************

#include <stdio.h> int main(){

    int num;

    printf("Ingrese un numero: ");

    scanf("%d",&num);
/* Primera situación: negativo o positivo */

    if(num < 0){

        printf("\nEl numero es negativo");

    }

    else{

        printf("\nEl numero es positivo");

    }
/* Segunda situación: par o impar */ 

    if( (num%2) == 0 )

        printf("\nEl numero es par");

    else

        printf("\nEl numero es impar");   

       

    return 0;

}

//*********************************************************************

El resultado de la ejecucion es el mismo.

Salida:

Ingresando -10

Ingresando 9:

Otro ejemplo teniendo varias condiciones respecto a una misma situacion:

//*********************************************************************

#include <stdio.h>

int main(){

    int var;

    printf("Ingrese numero: ",var);

    scanf("%d",&var);

    if( var<0 && (var%2)==0 ){   

        printf("\nEl numero es negativo y par.");

        var+=7; /* le suma 7 a var */

        printf("\n\t Ahora var es: %d",var);

    }

    else if(var<0){

        printf("\nEl numero es negativo e impar");

        var*=-2;

        printf("\n\t Ahora var es: %d",var);

    }

    else if(var>0){

        printf("\n El numero es positivo.");

        var/=10;

        printf("\n\t Ahora var es: %d",var);

    }

    return 0;

}

//*********************************************************************

Ahora, se ingresa un número y se ejecutará la primera condición, en caso de que no se cumpla se evaluará la segunda y en caso de que la segunda no se cumpla se evaluará la tercera.

* En caso de que se cumpla la primera condición no se va a realizar la comparación de la segunda ni la tercera.

* Si se colocan separados los if, sin usar else, se van a verificar siempre todas las condiciones.

* En teoría de ambas formas el resultado es el mismo, la diferencia la hace el tiempo en que se ejecuta el programa.

Nota: En las condiciones de if se hace uso de los operadores de relaciones para comparar.Y para en la primera condición también se incluyen los operadores lógicos para unir dos condiciones, en ese caso ambas deben cumplirse. La lectura de esa linea es: "Si var es menor que 0 y el resto de la división de var entre 2 es igual a 0".

Salida:

Ingresando -10;

Ingresando -17:

Ingresando 15:

Operadores Lógicos

Los operadores lógicos son:

Operador    significado   
     ||                    or      (ó)
     &&                and    (y)
     !                    not    (no)

El resultado de cualquiera de estos operadores es verdadero o falso.

Algunos usos serán vistos en los ejemplos de las siguientes entradas.

Operadores de Relaciones

Estos operadores son los que se utilizan para establecer comparaciones.

Operador    Comparación de:
==                   Igualdad
!=                   Diferencia
<                    Menor que
>                    Mayor que
<=                  Menor o igual que
>=                  Mayor o igual que

Este tipo de operadores son utilizados en las estructuras condicionales y ciclos del lenguaje C.
Mas adelante se presentaran ejemplos de su uso.

Contadores

Son variables que aumentan o decrementan en una unidad.

Operadores:

++    Incremento.

--    Decremento.

Sintaxis:

contador++;

En este caso el valor de contador incrementará una unidad (  contador=contador+1  ), esto lo indica el operador ++.

contador--;

Ahora contador decrementara en una unidad ( contador=contador-1 ), esto lo indica el operador --.

Ejemplo:
//*********************************************************************
#include <stdio.h> int main(){
    int variable=0; /* Se declara una variable comun y se inicializa con el valor 0 */
    printf("\nVariable es %d",variable);
    variable++; /* Variable incrementa una unidad*/
    variable++; /* Variable incrementa una unidad*/
    variable++; /* Variable incrementa una unidad*/
    printf("\nVariable es %d",variable);
    variable++; /* Variable incrementa una unidad*/
    variable++; /* Variable incrementa una unidad*/
    variable--; /* Variable decrementa una unidad*/
    variable++; /* Variable incrementa una unidad*/
    printf("\nVariable es %d",variable);
    variable--; /* Variable decrementa una unidad*/
    variable++; /* Variable incrementa una unidad*/
    printf("\nVariable es %d",variable);
    return 0;
}
//*********************************************************************

Salida:

Operadores de Asignación

Los operadores de asignación son:

=     Asigna un valor.

+=    Asigna suma.

-=    Asigna decremento.

*=    Asigna producto.

/=    Asigna cociente.

%=   Asigna resto.

Sintaxis:

variable+=numero;

El resultado de esto será que, variable va a ser igual a su valor original mas el valor de numero.

En el siguiente ejemplo, se muestra el uso de los operadores de asignación para modificar la variable num.

Ejemplo:

//*********************************************************************
#include <stdio.h>
int main(){
    int num=2;
    int val=5;
    printf("\n Num vale inicialmente %d y val tiene inicialmente %d",num,val);
    printf("\n\n Si num+=val la operacion realizada es num= %d + %d",num,val);
    num+=val;
    printf("\n\tNum vale: %d",num);
    printf("\n\n Si num-=val la operacion realizada es num= %d - %d",num,val);
    num-=val;
    printf("\n\tNum vale: %d",num);
    printf("\n\n Si num*=val la operacion realizada es num= %d * %d",num,val);
    num*=val;
    printf("\n\tNum vale: %d",num);
    printf("\n\n Si num/=val la operacion realizada es num= %d / %d",num,val);
    num/=val;
    printf("\n\tNum vale: %d",num);
    printf("\n\n Si num%%=val la operacion realizada es num= %d %% %d",num,val);
    num%=val;
    printf("\n\tNum vale: %d",num);
    return 0;
}
//*********************************************************************

Salida:

Operadores Aritméticos

Los operadores aritmeticos son:

+    suma

-    resta

*    multiplicación

/    división

%    módulo

La función de estos operadores es realizar la operación que representan (suma, resta, producto..).

Ejemplo: Operadores Aritméticos
//*********************************************************************
#include <stdio.h>
int main(){
    int a=10,b=7;
    int c;
    printf("Operadores Arimeticos");
    c=a+b;           /* c va a ser igual a la suma de a y b */
    printf("\n\t%i + %i = %i",a,b,c);
    c=a-b;            /* c va a ser igual a la resta de a menos b */
    printf("\n\t%i - %i = %i",a,b,c);
    c=a*b;            /* c va a ser igual a la multiplicacion de a por b */
    printf("\n\t%i * %i = %i",a,b,c);
    c=a/b;             /* c va a ser igual al cociente de la division de a entre b */
    printf("\n\t%i / %i = %i",a,b,c);
    c=a%b;          /* c va a ser igual al resto de la division de a entre b */
    printf("\n\t%i % %i = %i",a,b,c);
    return 0;
}
//*********************************************************************

Salida:

 

Ejemplo ingreso de datos personales

En el siguiente ejemplo se practica lo visto en las entradas anteriores.

Se declaran variables de diferentes tipos y el usuario debe asignarles valores a traves del teclado.

Luego se muestran en pantalla.

Nota:

La función system("cls"); limpia la pantalla.

La función fflush(stdin); limpia el bufer de entrada del teclado.

//*********************************************************************
#include <stdio.h>
int main(){
    char nombre[20],apellido[20],direccion[50],sexo;
    int edad,nac;
    long cedula;
    float estatura,peso;
    printf("\nIngrese los siguientes datos: ");
    printf("\n\tNumero de Cedula: ");
    scanf("%li",&cedula);
    printf("\n\tNombres: ");
    fflush(stdin);
    gets(nombre);
    printf("\n\tApellidos: ");
    fflush(stdin);
    gets(apellido);
    printf("\n\tDireccion: ");
    fflush(stdin);
    gets(direccion);
    printf("\n\tSexo (f/m): ");
    scanf("%c",&sexo);
    printf("\n\tEdad: ");
    scanf("%d",&edad);
    printf("\n\tAño de nacimiento: ");
    scanf("%d",&nac);
    printf("\n\tPeso: ");
    scanf("%f",&peso);
    printf("\n\tEstatura: ");
    scanf("%f",&estatura);
    system("cls");
    printf("\nSe han guardado los siguientes datos: \n");
    printf("\n  Numero de Cedula: %li",cedula);
    printf("\n  Nombres: %s",nombre);
    printf("\n  Apellidos: %s",apellido);
    printf("\n  Direccion: %s",direccion);
    printf("\n  Sexo (f/m): %c",sexo);
    printf("\n  Edad: %d",edad);
    printf("\n  Año de nacimiento: %d",nac);
    printf("\n  Peso: %.2f",peso);
    printf("\n  Estatura: %.2f",estatura);
    return 0;
}
//*********************************************************************

Salida:

Usando gets para guardar cadenas

Cuando leemos una cadena con scanf, guarda solo los caracteres que se encuentren antes de un espacio, como ocurrio en el ejemplo de la entrada anterior. Esto puede representar un problema si queremos leer varias palabras separadas por espacios.

Una forma de solucionarlo es usando gets, esta palabra reservada se utiliza de la siguiente forma:

gets(nombre_variable);

Ejemplo: Usando gets
//*********************************************************************
#include <stdio.h>
int main(){
    char y[50];
    printf("Ingrese una cadena: ");
    gets(y);
    printf("Guardado: %s",y);
    return 0;
}
//*********************************************************************

Se pide al usuario ingresar una cadena, se guarda con gets y por ultimo se muestra en pantalla el dato almacenado.

Salida: