viernes, 22 de enero de 2016

Animacion en C++

Animacion en C++
Objetivo : 
Realizar una animacion en Dev C++ , utilizando la libreria winbgim.

Descripcion:

Este programa realiza una animacion de un automovil moviendose a traves de una autopista , utilizando recursos como ciclos for , e interfaz grafica.

Codigo :

#include <winbgim.h>      
#include <conio.h>          
int i,j;
int main()
{
    initwindow(880,400);    
    settextstyle(0,0,2);
    while(!kbhit())                                                            
    {
    for(j=0;j<=70;j++){                                            
    setcolor(YELLOW);      
    circle(750,40,j);}          
     cleardevice();                
     i++;
     if(i>getmaxx())            
     i=-250;
        {
            setcolor(BLUE);
            outtextxy(60,60,"Presione cualquier tecla");  
            setcolor(BLUE);{
            line(i,200,i,300);                                        
            line(i,200,i+250,200);
            line(i+250,200,i+250,300);}
            {
            line(i,300,i+35,300);
            line(i+85,300,i+165,300);
            line(i+215,300,i+250,300);}
            circle(i+60,300,25);
            circle(i+190,300,25);
            rectangle(i+190,210,i+240,260);
            setcolor(WHITE);
            arc(i+190,300,0-i,60-i,25);
            arc(i+60,300,0-i,60-i,25);
            sleep(5);
        }
    }
    getch();
}

Link de descarga del codigo:
https://drive.google.com/file/d/0BwYfV-btWlrFUDNPU2RjUkdYX00/view?usp=sharing

Correccion Evaluacion Segundo Bloque

Ejercicio Matriz

Objetivo : 

Crear un programa que rellene una matriz , utilizando funciones.

Descripción

Este programa crea una matriz de 3x4 que inicializa en 0 , para luego ser completada por el usuario mediante el teclado.

Codigo:

#include <stdio.h>
#include <conio.h>
#include <windows.h>

void ceros(int matriz[3][4]);
void ingresar();

int main()
{
int matriz[3][4];
ceros(matriz);

ingresar();

return(0);
getch ();
}


void ceros(int matriz[3][4])
{
int fila, columna;
for(fila=0;fila<=3;fila++)
for(columna=0;columna<=4;columna++)
matriz[fila][columna]=0;




for(fila=0;fila<3;fila++)
{
for(columna=0;columna<4;columna++)
{
printf("%i ", matriz[fila][columna]);
}
printf("\n");
}
getch();


}

void ingresar()
{

int matriz[3][4], i,j, vector [3]={0,0,0};
      for(i=0; i<3; i++)
  for(j=0; j<4; j++)
    {
printf("Ingrese el elemento %d y Columna=%d de la matriz:\n", i,j);
scanf("%d", &matriz[i][j]);
vector[i]=vector[i]+matriz[i][j];
      }
 
 
   printf("La Matriz generada es:\n\n");
      for(i=0; i<3; i++)
      {
for(j=0; j<4; j++)
    {
printf("%d ", matriz[i][j]);
    }
printf("\n");
      }
printf("%d\t", vector[i]);
      getch();
}

Captura de Pantalla:

Link del Programa:


Matrices en C++

Matrices en C++. Uso, declaración, y sintaxis de las matrices en C++

Las matrices o como algunos las llaman "arreglos multidimensionales" son una estructura de datos bastante similar a los vectores o arreglos; de hecho una matríz no es más que una serie de vectores contenidos en en otro (u otros), es decir, una matriz es un vector cuyas posisiones son otros vectores. Hablemos con más detalle de esto para quedar más claros.
Nota: Te recomiendo ver y comprender la sección dearrays o vectores, antes de iniciar con este artículo para poder dominar el tema de éste con más facilidad.
Primero dejemos claro qué es una matriz. En términos generales, una mátriz es una estructura conformada por filas y conlumnas, idealmente más de dos filas y columnas, de hecho podemos decir que si una "matriz" tiene una única fila o una única columna, entonces estamos hablando de un vector.
La intersección de una fila y una columna de la matriz son las casillas y cada una de ellas podrá poseer información, simple o compleja (ya dependerá de nuestras necesidades).
Ahora, tal como dije antes un vector posee una única fila (o columna, como lo quieras ver) y de este modo un grupo de vectores unidos conforman una matríz, es por esto que al comienzo dije que una matríz es un vector conformado por otra serie de vectores.
Viendolo desde el punto de vista de la programación, una matriz entonces, es un vector cuyas posiciones (de la cero a la n) son, cada una de ellas, otro vector
Como siempre, la mejor forma de comprender algo es viendo un ejemplo en acción, así que veamos un buen ejemplo de matrices en C++

Matrices en C++ un buen ejemplo

Muy bien voy a retomar el ejemplo de la sección anterior donde teníamos la necesidad de almacenar los titulos y los autores de una serie de libros dada.
Tal como mencioné en dicha sección, una solución alternativa al problema, además de correcta y adecuada; es crear una matríz que almacenará en la primera columna los títulos, y en la segunda columna los autores; cada fila será entonces la información completa de un libro.
Para solucionar este problema, aprendamos primero algunas normas básicas para poder crear y usar matrices en C++.

¿Cómo se crea una Matriz en C++?

Declarar una matriz en C++ es muy similar a la de un vector, se deben seguir las mismas normas para declarar una variable pero una vez más con un pequeño cambio en la sintaxis. Primero necesitaremos saber el tipo de los datos que irán al interior de este (números, decimales o cadenas de texto, etc.) necesitamos también, como siempre, un nombre para la matriz y un tamaño máximo tanto para las filas como para las columnas. La sintaxis para declarar una matriz en C++ es la siguiente:
 
tipoDato nombreMatriz[filas][columnas];
 
Nota: Recuerda que en C++, no es posible crear de una manera sencilla un vector (y por ende una matriz)capaz de almacenar una cantidad de información indefinida, es necesario ingresar con antelación la cantidad de datos (filas y columnas) que la matriz tendrá.
Tenemos entonces, como podrás ver, que la sintáxis es casi la misma excepto que hemos añadido un par de corchetes "[]" más esta vez y al interior de los éstos debemos poner el número de filas y columnas máximas de la matriz, respectivamenteque. Veamos un ejemplo en el cual pondré la declaración de varias matrices de diferentes tipos y tamaños en C++.

Declaración de una matriz en C++

 
int myMatriz1[10][5];
float myMatriz2[5][10];
string myMatriz3[15][15];
bool myMatriz4[1000][3];
 
Veamos rápidamente que representa cada línea del código anterior.

Línea 1

Esta línea contiene la declaración de una matriz llamada myMatriz1 que tendrá 10 filas y 5 columnas y cada una de las 50 casillas tendrá datos de tipo entero.

Línea 2

Esta línea contiene la declaración de una matriz llamada myMatriz2 que tendrá 5 filas y 10 columnas y cada una de las 50 casillas tendrá datos de tipo flotante.

Línea 3

Esta línea contiene la declaración de una matriz llamada myMatriz3 que tendrá 15 filas y 15 columnas (una matríz cuadrada) y cada una de las 225 casillas tendrá datos de tipo string.

Línea 4

Esta línea contiene la declaración de una matriz llamada myMatriz4 que tendrá 1000 filas (sí, leíste bien) y 3 columnas y cada una de las 3000 casillas (también leíste bien, tres mil casillas) tendrá datos de tipo boleano.
Ya que está claro cómo se declara una matriz, vamos a inicializarla, es decir darle un valor a cada casilla, según su tipo de dato.

¿Cómo inicializar una matriz en C++?

En cuanto tenemos declarado una matriz, es posible asignarle valores a cada una de sus casillas, evidentemente estos valores deben coincidir con el tipo de dato que le asignamos a dicha matriz
Voy a mostrar a continuación formas distintas de inicializar una matriz, todas son validas, ya es cuestión de nuestras necesidades y conocimientos determinar cuál es útil y en qué momento. Veamos entonces:

Forma 1 de declarar una matriz

 
int myMatriz1[2][2] = {{1,2},{3,4}};
 
Aquí hemos declarado una matriz de tipo int de dos filas y dos columnas y la hemos inicializado con diferentes valores. El valor inicial corresponde a la casilla 0,0 (fila cero, columna cero) y tiene el valor de 1, en la fila cero columna uno tenemos el valor de 2, en la fila uno columna cero el valor de 3 y finalmente en la fila uno columna uno el valor de 4. Es importante notar que el primer tanto la fila como la columna comienzan desde cero y no desde uno, por esto la primer casilla corresponde a la fila y columna cero.
Bien! Ya sabemos cómo declarar una matriz en C++, sin embargo aun no sabemos cómo acceder a lso datos que estas contienen. Veámoslo:

Obtener el valor de una casilla específica

Para acceder al valor de una casilla nuevamente haremos uso de los corchetes, pero esta vez no para declar tamaños (porque eso ya lo hicimos) sino para indicar posiciones (fila y columna).
 
int myMatriz1[2][2] = {{1,2},{1,1}}; //Matriz con 4 elementos
int fila1Casilla1 = myMatriz[1][1]; //Para acceder a la casilla 1,1 se usan dichos indices
int primerNumero = myMatriz[0][0]; //La primer casilla siempre será la de la fila 0 columna 0
 
Como podemos ver, para acceder a un valor específico conociendo el índice de la casilla, solo basta con escribir dicho índice entre los corchetes "[][]", recuerda que el índice comienza desde cero, así por lo tanto en una matriz de vector de 2 por 2 (como el ejemplo), el último elemento está en el índice 1 y el primer elemento en el índice 0.

Recorrer una matriz en C++

Para obtener todos los datos que se encuentran al interior de una matriz, debemos acceder a cada posición y esto se hace fácilmente con dos ciclos for (anidados). La lógica de este procedimiento es la siguiente, el primer ciclo for comenzará desde cero e ira hasta el número de filas, de modo que la variable de control que generalmente llamamos "i", será la que va a ir variando entre cero y el tamaño del array, de esta forma al poner la i al interior de los corchetes, estaremos accediendo al valor de cada fila y el segundo ciclo irá de cero al número de columnas y normalmente se usa la variable llamada j para acceder a cada columna, veamos:
Nota:En el código acontinuación uso una forma sencilla y rápida de obtener la cantidad o número de filas de una matriz y también cómo obtener el número o cantidad de columnas de una matriz. Ten en cuenta que esto es importante, pues a veces no tenemos la certeza del tamaño de la matriz.
 
#include 

using namespace std;

int main()
{
    int edades[3][2] = {{1,2},{9,8},{14,21}};
    int filas = (sizeof(edades)/sizeof(edades[0]));
    int columnas = (sizeof(edades[0])/sizeof(edades[0][0]));
    for (int i = 0; i < filas; i++)
    {
        for (int j = 0; j < columnas; j++)
        {
            cout<<edades[i][j]<<endl;
        }
    }
}
 
Vamos a ver de forma resumida en qué consiste y que hace cada una de estas líneas

Línea 1:

Tenemos en la primera línea la declaración de una matriz que contiene las edades de tres parejas de personas y asignamos cada uno de los valores.

Líneas 2 y 3:

En estas líneas, tenemos la declaración del número de filas y columnas de la matriz, que serán el límite del primer y segundo ciclo, respectivamente. Para mas detalles de esto, verifica la información sobre el operador sizeof.

Líneas 4 a 7:

Aquí, tenemos entonces un ciclo for que comienza en cero y termina en el número de filas y luego tenemos otro ciclo for (anidado) que irá de cero hasta el número de columnas (es importante notar que la condición usada en ambos ciclos es estrictamente menor "<" y no menor o igual "<="), al interior del segundo ciclo, es donde accedemos a cada uns de las casillas de la matriz usando loc corchetes.

Línea 8:

La octava línea es quizá la más vital aunque sin las demás no tendríamos nada. En esta línea, estamos accediendo a cada una de las casillas de la matriz, fila por fila y columna por columnaaccedemos a cada elemento poniendo entre los corchetes la variable i y j, que son las que están cambiando a medida que los ciclos van "girando", así estaremos accediendo a todos los elementos e imprimiéndolos por pantalla por medio de cout.
Muy bien, llegó el momento de afianzar nuestros conocimientos viendo un ejemplo. Ahora que tenemos claro como declarar un vector en C++, como recorrerlo y como acceder a sus datos, vamos a ver un ejemplo basado en el problema que planteé al inicio de esta sección (el de los libros).

Ejemplo de Matrices en C++

El problema es simple, queremos crear un programa con el cual podamos guardar los títulos y los autores de diferentes libros sin perder ninguno de ellos. El usuario es el encargado de suministrar la información de cada libro. Vamos a suponer que el usuario solo podrá ingresar un máximo de 5 libros, para así tener un tamaño de vector fijo. Veamos entonces cómo se haría esto usando matrices:
 
#include "iostream"
#include "stdio.h"
#include "string"

using namespace std;

int main()
{
    string libros[5][2];
    cout << "Por favor ingrese la siguiente información de los Libros: \n";
    string titulo ,autor;
    for(int i = 0; i < 5; i++)
    {
        cout << "\n******* Libro " << i + 1 << "********:\n";
        cout << "Titulo: ";
        getline(cin,titulo);
        cout << "Autor: ";
        getline(cin,autor);
        libros[i][0] = titulo;
        libros[i][1] = autor;
    }

    system("pause");

    return 0;
}
 

Notar que en el código anterior, debido a que tenemos la completa certeza de sólo usar dos columnas, no es necesario usar otro ciclo for (de hecho, eso complicaría todo) basta con poner de manera explícita que el valor del título va en la columna cero y el del autor en la columna uno.

Constructores

^
Los constructores son funciones miembro especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.
Los constructores son especiales por varios motivos:
  • Tienen el mismo nombre que la clase a la que pertenecen.
  • No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
  • No pueden ser heredados.
  • Por último, deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
Sintaxis:
class <identificador de clase> {
    public:
        <identificador de clase>(<lista de parámetros>) [: <lista de constructores>] {
            <código del constructor>
        }
        ...
}
Añadamos un constructor a nuestra clase pareja:
#include <iostream> 
using namespace std;
 
class pareja {
   public:
      // Constructor
      pareja(int a2, int b2);
      // Funciones miembro de la clase "pareja"
      void Lee(int &a2, int &b2);
      void Guarda(int a2, int b2);
   private:
      // Datos miembro de la clase "pareja"
      int a, b; 
};

pareja::pareja(int a2, int b2) {
   a = a2;
   b = b2;
}

void pareja::Lee(int &a2, int &b2) {
   a2 = a;
   b2 = b;
}

void pareja::Guarda(int a2, int b2) {
   a = a2;
   b = b2;
}

int main() {
   pareja par1(12, 32);
   int x, y;
   
   par1.Lee(x, y);
   cout << "Valor de par1.a: " << x << endl;
   cout << "Valor de par1.b: " << y << endl;
   
   return 0;
}
Si no definimos un contructor el compilador creará uno por defecto, sin parámetros, que no hará absolutamente nada. Los datos miembros del los objetos declarados en el programa contendrán basura.
Si una clase posee constructor, será llamado siempre que se declare un objeto de esa clase. Si ese constructor requiere argumentos, como en este caso, es obligatorio suministrarlos.
Por ejemplo, las siguientes declaraciones son ilegales:
pareja par1;
pareja par1();
La primera porque el constructor de "pareja" requiere dos parámetros, y no se suministran.
La segunda es ilegal por otro motivo más complejo. Aunque existiese un constructor sin parámetros, no se debe usar esta forma para declarar el objeto, ya que el compilador lo considera como la declaración de un prototipo de una función que devuelve un objeto de tipo "pareja" y no admite parámetros.
Cuando se use un constructor sin parámetros para declarar un objeto no se deben escribir los paréntesis.
Y las siguientes declaraciones son válidas:
pareja par1(12,43);
pareja par2(45,34);

Ejercicio Clase en C++

Objetivo : 
Crear un programa aplicando la teoria de clases mediante el uso del Dev C++.

Descripcion:

Este programa utiliza una clase llamda datos , en el cual se almacenan los datos de un empleado cualquiera.
Codigo:
#include <conio.h>
#include <stdio.h>


class Datos {
      public:
             int edad;

             char nombre[10];
      public:                  
      void imprimirinfo(void);
      void leerinfo(void);

      };

   
   
void Datos::imprimirinfo(void)
{      
printf ("Nombre: %s \n ",nombre);

printf ("Edad: %d",edad);

}
               void Datos::leerinfo(void)
               {
                printf ("Ingrese nombre:");
                scanf ("%s",&nombre);
                printf ("Ingrese edad");
                scanf ("%d",&edad);
                }

void fueraclase(char nombre[10],int edad)
{
     
     printf ("Nombre: %s \n ",nombre);

printf ("Edad: %d",edad);

}


main ()
     {  
         Datos empleado;    
        empleado.leerinfo();
        empleado.imprimirinfo();
        fueraclase(empleado.nombre,empleado.edad);
     
     getch ();
}
Captura de Pantalla:

Link Programa:

Clases C++

^
Ahora va a empezar un pequeño bombardeo de nuevas palabras reservadas de C++, pero no te asustes, no es tan complicado como parece.
La primera palabra que aparece es lógicamente class que sirve para definir una clase y para declarar objetos de esa clase. Su uso es parecido a la ya conocida struct:
class <identificador de clase> [<:lista de clases base>] {
   <lista de miembros>
} [<lista de identificadores de objetos>]; 
La lista de clases base se usa para derivar clases, de momento no le prestes demasiada atención, ya que por ahora sólo declararemos clases base.
La lista de miembros será en general una lista de funciones y datos.
Los datos se declaran del mismo modo en que lo hacíamos hasta ahora, salvo que no pueden ser inicializados, recuerda que estamos hablando de declaraciones de clases y no de definiciones de objetos. En el siguiente capítulo veremos el modo de inicializar las variables de un objeto.
Las funciones pueden ser simplemente declaraciones de prototipos, que se deben definir aparte de la clase pueden ser también definiciones.
Cuando se definen fuera de la clase se debe usar el operador de ámbito "::".
Lo veremos mucho mejor con un ejemplo.
#include <iostream> 
using namespace std;
 
class pareja {
   private:
      // Datos miembro de la clase "pareja"
      int a, b; 
   public:
      // Funciones miembro de la clase "pareja"
      void Lee(int &a2, int &b2);
      void Guarda(int a2, int b2) {
         a = a2;
         b = b2;
      }
};

void pareja::Lee(int &a2, int &b2) {
   a2 = a;
   b2 = b;
}

int main() {
   pareja par1;
   int x, y;
   
   par1.Guarda(12, 32);
   par1.Lee(x, y);
   cout << "Valor de par1.a: " << x << endl;
   cout << "Valor de par1.b: " << y << endl;

   return 0;
}
Nuestra clase "pareja" tiene dos miembros de tipo de datos: a y b.
Y dos funciones, una para leer esos valores y otra para modificarlos.
En el caso de la función "Lee" la hemos declarado en el interior de la clase y definido fuera, observa que en el exterior de la declaración de la clase tenemos que usar la expresión:
void pareja::Lee(int &a2, int &b2)
Para que quede claro que nos referimos a la función "Lee" de la clase "pareja". Ten en cuenta que pueden existir otras clases que tengan funciones con el mismo nombre, y también que si no especificamos que estamos definiendo una función de la clase "pareja", en realidad estaremos definiendo una función corriente.
En el caso de la función "Guarda" la hemos definido en el interior de la propia clase. Esto lo haremos sólo cuando la definición sea muy simple, ya que dificulta la lectura y comprensión del programa.
Además, las funciones definidas de este modo serán tratadas como inline, y esto sólo es recomendable para funciones cortas, ya que, (como recordarás), en estas funciones se inserta el código cada vez que son llamadas.

Ejercicio Herencia C++

Objetivo :
Crear un programa en C usando el concepto de herencia.

Descripcion
Este programa contiene el concepto de herencia al utilizar la clase datos , y la hija Datos_H, funciona completando datos desde el teclado


Codigo

#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>

class Datos{
private:
char nombre[10];
int cedula;
public:
void Impnom()
{
 strcpy(nombre,"Oscar");
printf ("%s",nombre);
 printf("\n");}
void Impced()
{
cedula=1719415703;
printf ("%d",cedula);
 printf("\n");}
};


class DatosH: public Datos{
private:
public:
};


main()
{
 DatosH DatosH_1;
 DatosH_1.Impnom();
 DatosH_1.Impced();

 getch();
 }

Captura de Pantalla


Link programa:
https://drive.google.com/file/d/0BwYfV-btWlrFWGxyMnFFenFHTFU/view?usp=sharing

Herencia en C++

Herencia en C++

C++ soporta herencia permitiendo a una clase incorporar otra clase dentro de su declaración. Antes de discutir los detalles y la teoría, se procede a comenzar por un ejemplo de herencia. La siguiente clase, llamada 'VehiculoRodante', define muy ampliamente a vehículos que viajan por la carretera. Este almacena el numero de ruedas que un vehículo tiene y el numero de pasajeros que puede llevar.
Un regla sencilla para recordar esto es: "Una clase derivada hereda de una clase base"
#include <iostream>
using namespace std;

class base {

 int i, j;

public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};

class derivada : public base {

 int k;

public:
 derivada(int x) { k = x; }
 void mostrar_k() { cout << k << "\n"; }
};

int main()
{
 derivada obj(3);
 
 obj.set(1, 2); // accesar a miembro de base
 obj.mostrar(); // accesar a miembro de base

 obj.mostrar_k(); // usa miembro de la clase derivada

return 0;
}
Cuando una clase hereda de otra, los miembros de la clase base se convierten en miembros de la clase derivada. El estado de acceso de los miembros de la clase base dentro de la clase derivada es determinado por el especificador de acceso usado para heredar la clase base. El especificador de acceso de la clase base debe ser 'public', 'private' o 'protected'. Si el especificador de acceso no es usado, entonces se usara private por defecto si la clase derivada es una clase. Si la clase derivada es una 'struct' entonces 'public' es el acceso por defecto por la ausencia de un expecificador de acceso explícito. Examinemos las ramificaciones de usar accesos public o private. ( El especificador 'protected' se describe en la próxima sección.)
Cuando una clase base es heredada como 'public', todos los miembros públicos de la clase base se convierten en miembros de la clase derivada. En todos los casos, los elementos privados de la clase base se mantienen de esa forma para esta clase, y no son accesibles por miembros de la clase derivada. Por ejemplo, en el siguiente programa, los miembros públicos de 'base' se convierten en miembros publics de 'derivada'. Encima, son accesibles por otras partes del programa.

Validador Cedula Ecuatoriana en Excel

Objetivo : Crear una hoja de calculo en excel , aplicando los algoritmos de validacion de la cedula ecuatoriana

Descripcion

Esta aplicacion ingresa el usuario su numero de cedula , y mediante un algoritmo lo verifica.
Captura de Pantalla:

Link de descarga del archivo:
https://drive.google.com/file/d/0BwYfV-btWlrFVlpNaVFvRElBMDg/view?usp=sharing&resourcekey=0-SlCYiXOH_4oCwhEctk3siQ

Validador Cedula ecuatoriana en C

Objetivo : 
Crear un programa diseñado en c , con el fin de aplicar el algoritmo de la cedula ecuatoriana.

Descripcion
En este programa se valida la cedula ecuatoriana utilizando punteros , y conceptos basicos de variables

Codigo: 
#include <conio.h>
#include <stdio.h>
#include <windows.h>

int *ptrdecenasuperior,*ptrtotalpares,*ptrtotalimpares,*ptrtotalsuma,*ptrverificacion;
int j=0,i,decenasuperior,totalpares,totalimpares,totalsuma,verificacion;
main()
{

char cedula[9];
int num[9],impar[4];
int *ptrdecenasuperior=&decenasuperior;
int *ptrtotalpares=&totalpares;
int *ptrtotalimpares=&totalimpares;
int *ptrtotalsuma=&totalsuma;

system("Color 6F");

printf("******************Sistema Verificador de cedula ecuatoriana***********\n");

printf("Ingrese su cedula:");
scanf("%s",&cedula);
for(i=0;i<10;i++)
{

switch(cedula[i])
{
               case 49:
                    num[i]=1;
                    break;
               case 50:
                    num[i]=2;
                    break;
               case 51:
                    num[i]=3;
                    break;
                case 52:
                    num[i]=4;
                    break;
               case 53:
                    num[i]=5;
                    break;
                case 54:
                    num[i]=6;
                    break;                  
                case 55:
                    num[i]=7;
                    break;
                case 56:
                    num[i]=8;
                    break;
                case 57:
                    num[i]=9;
                    break;
                case 48:
                    num[i]=0;
                    break;

default:
                 
printf("Error solo puedes ingresar numeros , no letras");
break;
                 }
}


printf ("La cedula ingresada es :");
for(i=0;i<10;i++)
{

printf("%d",num[i]);

}

printf ("\n");



for(i=0;i<5;i++)
{
impar[i]=num[j]*2;
if(impar[i]>=9)
{
impar[i]=impar[i]-9;
}
j=j+2;
}




totalpares=num[1]+num[3]+num[5]+num[7];

totalimpares=impar[0]+impar[1]+impar[2]+impar[3]+impar[4];



totalsuma=totalimpares+totalpares;


decenasuperior=((totalsuma/10)+1)*10;


verificacion=decenasuperior-totalsuma;

printf("Suma total de pares : %d\n",*ptrtotalpares);
printf("Suma de impares : %d\n",*ptrtotalimpares);
printf("Suma total: %d\n",*ptrtotalsuma);
printf("Decena inmediata superior : %d\n",*ptrdecenasuperior);


if(verificacion==num[9])
{
printf ("*********************Resultados*********************\n");
printf("La cedula ingresada es correcta\n");
}
else
{
    printf ("*********************Resultados*********************\n");
printf("La cedula ingresada es incorrecta\n");
}
getch();

}
Captura de Pantalla: 

Link de descarga del archivo:
https://drive.google.com/file/d/0BwYfV-btWlrFZWxmSXdxTUlrR3c/view?usp=sharing



Validador Cedula ecuatoriana



Algoritmo validador cédula ecuatoriana
  •  La cedula ecuatoriana está formada por los dos primeros dígitos que corresponden a la provincia donde fue expedida, por lo cual los dos primeros números no será mayor a 24 ni menor a 1.
  •   El tercer digito es un número menor a 6 (0, 1, 2, 3, 4, 5).
  •   Los siguientes hasta el noveno digito son un número consecutivo.
  •     Y el décimo digito es el digito verificador.
  • Los coeficientes usados para verificar el décimo dígito de la cédula, mediante el algoritmo “Módulo 10”

COEFICIENTES = 2.1.2.1.2.1.2.1.2

Conceptos Programacion orientada a objetos

Objetivo : Realizar una consulta de la programación orientada a objetos investigando sus características , teoría y fundamentos

Definición
La programación orientada a objetos (POO, u OOP según sus siglas en inglés) es un paradigma de programación que usa objetos en sus interacciones, para diseñar aplicaciones y programas informáticos.
Está basada en varias técnicas, incluyendo herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.
Objetos
Los objetos son entidades que tienen un determinado "estado", "comportamiento (método)" e "identidad":
El estado está compuesto de datos o informaciones; serán uno o varios atributos a los que se habrán asignado unos valores concretos (datos).
El comportamiento está definido por los métodos o mensajes a los que sabe responder dicho objeto, es decir, qué operaciones se pueden realizar con él.
La identidad es una propiedad de un objeto que lo diferencia del resto; dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).
Clases
Las clases son plantillas que agrupan comportamiento (métodos) y estados (atributos) de los futuros objetos.
Los objetos son instancias de una clase. Usando el símil “variable – tipo” de la programación estructurada, se entiendo que un objeto es una variable que tiene el comportamiento y estados del tipo (objeto)

Herencia
La herencia es específica de la programación orientada a objetos, donde una clase nueva se crea a partir de una clase existente. La herencia (a la que habitualmente se denomina subclases) proviene del hecho de que la subclase (la nueva clase creada) contiene las atributos y métodos de la clase primaria. La principal ventaja de la herencia es la capacidad para definir atributos y métodos nuevos para la subclase, que luego se aplican a los atributos y métodos heredados.
Esta particularidad permite crear una estructura jerárquica de clases cada vez más especializada. La gran ventaja es que uno ya no debe comenzar desde cero cuando desea especializar una clase existente. Como resultado, se pueden adquirir bibliotecas de clases que ofrecen una base
Poliformismo
Polimorfismo es la propiedad que indica, literalmente, la posibilidad de que una entidad tome muchas formas. En términos de la POO, el polimorfismo permite referirse a objetos de clases diferentes mediante el mismo elemento de programa y realizar la misma operación de diferentes formas, según sea el tipo del objeto que sea referenciado en ese momento. Por ejemplo, cuando se describe la clase vehículo, se puede observar que la operaciones desplazar o frenar son fundamentales en todos los vehículos, de modo de cada tipo de vehículo debe poder realizar .
Encapsulación

La encapsulación es un mecanismo que consiste en organizar datos y métodos de una estructura, conciliando el modo en que el objeto se implementa, es decir, evitando el acceso a datos por cualquier otro medio distinto a los especificados. Por lo tanto, la encapsulación garantiza la integridad de los datos que contiene un objeto.