miércoles, 30 de noviembre de 2016

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:

martes, 29 de noviembre de 2016

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.

lunes, 28 de noviembre de 2016

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.

sábado, 26 de noviembre de 2016

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:

viernes, 25 de noviembre de 2016

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:

jueves, 24 de noviembre de 2016

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:
 

miércoles, 23 de noviembre de 2016

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:

martes, 22 de noviembre de 2016

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:

lunes, 21 de noviembre de 2016

Ingresar datos con scanf

La funcion scanf pertenece a la libreria stdio.h y permite que el usuario le asigne un valor a una variable a traves del teclado.

Sintaxis:
    scanf("%tipo_dato",&nombre_variable);

Los datos que son guardados en las variables se pierden al finalizar la ejecución del programa.
A continuación ejemplos para ingresar datos de diferentes tipos.

Se muestra un mensaje en el que se le pide al usuario que ingrese un dato y al colocar scanf el programa espera a que el usuario ingrese un dato y presione enter. Luego de esto mostrara lo que guardo.

Ejemplo 1: Guardando dato entero
//*********************************************************************
#include <stdio.h>
int main(){
    int y;
    printf("Ingrese un numero entero: ");
    scanf("%d",&y);
   
    printf("Guardado: %d",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %d para indicar que se va a guardar un valor de tipo entero, también puede usarse %i. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Nota: En caso de que se escriba un número decimal, se va a guardar sólo la parte entera.
Salida:

Ejemplo 2: Guardando dato entero largo
//*********************************************************************
#include <stdio.h>
int main(){
    long y;
    printf("Ingrese un numero entero largo: ");
    scanf("%li",&y);
    printf("Guardado: %li",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %li para indicar que se va a guardar un valor de tipo entero largo, también puede usarse %ld. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Salida:

Ejemplo 3: Guardando dato real
//*********************************************************************
#include <stdio.h>
int main(){
    float y;
    printf("Ingrese un numero real: ");
    scanf("%f",&y);
    printf("Guardado: %f",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %f para indicar que se va a guardar un valor de tipo real. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Salida:

Ejemplo 4: Guardando real doble
//*********************************************************************
#include <stdio.h>
int main(){
    double y;
    printf("Ingrese un numero real: ");
    scanf("%lf",&y);
    printf("Guardado: %lf",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %lf para indicar que se va a guardar un valor de tipo real largo. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Salida:

Ejemplo 5: Guardando dato caracter
//*********************************************************************
#include <stdio.h>
int main(){
    char y;
    printf("Ingrese un caracter: ");
    scanf("%c",&y);
   
    printf("Guardado: %c",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %c para indicar que se va a guardar un valor de tipo caracter. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Salida:

Ejemplo 6: Guardando cadena de caracteres.
//*********************************************************************
#include <stdio.h>
int main(){
    char y[20];
    printf("Ingrese un cadena de max 20 caracteres: ");
    scanf("%s",&y);
    printf("Guardado: %s",y);
    return 0;
}
//*********************************************************************


 Se escribe la instrucción scanf y entre comillas %s para indicar que se va a guardar un valor de tipo cadena. Seguidamente se coloca & con el nombre de la variable en la que se va a almacenar, para indicar la dirección de memoria.
Salida:
  
Nota:
Es muy importante recordar escribir el simbolo & porque indica la dirección de memoria en la que se almacenaran los datos ingresados por el usuario. En caso de olvidar esto el programa dejara de funcionar.

sábado, 19 de noviembre de 2016

Datos Cadena de Caracter

Este tipo de datos almacena varios caracteres.
Se declaran usando char pero indicandole un tamaño char[tamaño].

Ejemplo 1: Declaración de cadena de caracter.
//*********************************************************************
#include <stdio.h>
int main(){
    char cadena[10];
    cadena[0]='C';
    cadena[1]='a';
    cadena[2]='d';
    cadena[3]='e';
    cadena[4]='n';
    cadena[5]='a';
    cadena[6]=' ';
    cadena[7]='1';
    cadena[8]='\0';
    printf("\nLa cadena: %s",cadena);
    return 0;

}
//*********************************************************************

Se declara una cadena llamada cadena y se le asigna un tamaño de 10 caracteres.
Aparte se inicializa caracter por caracter, y se muestra en pantalla completa.
\0 indica el final de la cadena.
Salida:

Ejemplo 2: Declarando cadena de caracteres.
//*********************************************************************
#include <stdio.h>
int main(){
    char cad[]="HOLA MUNDO";
    printf("\n La cadena completa es %s",cad);
    printf("\n Simbolo 3 de la cadena: %c",cad[2]);
    return 0;

}
//*********************************************************************

En este caso se declaro una cadena pero no se le indico un tamaño, inmediatamente se inicializo con la cadena entre comillas dobles.
En la siguiente linea se muestra la cadena completa con %s y colocando después de la coma sólo el nombre de la cadena.
Por último se muestra el simbolo 3 de la cadena, con %c y se indica el nombre de la cadena y la posicion (2 porque se inicia desde 0).
  Salida:

Ejemplo 3: Declarando cadena de caracteres
//*********************************************************************
#include <stdio.h>
int main(){
    char var[5]={'H','e','l','l','o'};
    printf("%s",var);
    return 0;

}
//*********************************************************************

Salida:
  

viernes, 18 de noviembre de 2016

Datos Real Largo

Los datos tipo real largo o doble, almacenan datos reales mas grandes que float.
Para declarar variables de este tipo se utiliza la palabra reservada double.

Ejemplo 1: Declaración de variable double.
//*********************************************************************
#include <stdio.h>
int main(){
    double n;
    n=988349.32434;
    printf("\nlong float: %lf",n);
    return 0;
}
//*********************************************************************

Se declara una variable, se le asigna un valor y se muestra en pantalla.
Salida:

Ejemplo 2: Declaración de variables double.
//*********************************************************************
#include <stdio.h>
int main(){
    double d1=999999999.888888,d2=-5421552155.21;
    printf("\n Reales largos %lf y %lf",d1,d2);
    return 0;
}
//*********************************************************************

Se declaran dos variables tipo double, se le asignan valores y se muestra en pantalla.
Salida:
Para declarar constantes de tipo double se puede usar #define y const, como se muestra en los siguientes ejemplos.
   
Ejemplo 3: Declaración de constante double con #define
//*********************************************************************
#include <stdio.h>
#define ci 8542225543.141595
int main(){
    printf("%lf",ci);
    return 0;
}
//*********************************************************************

Se declara una constante tipo double con #define y se muestra en pantalla.
Salida:

Ejemplo 4: Declaración de constante double con const
//*********************************************************************
#include <stdio.h>
int main(){
    const double co=314159265656465.62;
    printf("%lf",co);
    return 0;
}
//*********************************************************************

Se declara una constante double con const y se muestra en pantalla.
Salida:
 

jueves, 17 de noviembre de 2016

Datos Entero Corto


Este tipo de dato almacena numeros enteros.
Para la declaración de variables se utiliza la palabra reservada short.

Ejemplo 1: Declaración de variable entera corta.

//*********************************************************************
#include <stdio.h>
int main(){
    short x;
    x=5;
    printf("\nNumero corto: %i",x);
    return 0;

}
//*********************************************************************


Se declara una variable de tipo short, en la siguiente linea, se asigna un valor y por ultimo se muestra en pantalla.
Salida:

Ejemplo 2: Declaración de variables enteras cortas.
//*********************************************************************
#include <stdio.h>
int main(){
    short q=1,w=2,e=-3;
    printf("\nq= %d, w=%i, e= %d",q,w,e);
    return 0;

}
//*********************************************************************


Se declaran tres variables tipo short y se les asignan valores, luego se muestra en pantalla.
Salida:


Para declarar constantes de tipo short se pueden usar las palabras reservadas #define y const como se muestra en los siguientes ejemplos:

Ejemplo 3: Declaración de constante entera corta usando #define
//*********************************************************************
#include <stdio.h>
#define p 3
int main(){
    printf("constante entera corta: %i",p);
    return 0;
}
//*********************************************************************

Se declara una constante p con #define y se muestra en pantalla.

Salida:

Ejemplo 4: Declaración de constante entera corta usando const
//*********************************************************************
#include <stdio.h>
const short constante=-5; int main(){
    printf("La constante vale: %d",constante);
    return 0;
}
//*********************************************************************

Se declara una constante con la palabra reservada const, y luego se muestra en pantalla.

Salida: