Cesar Systems

Herramientas Informaticas

Categoría: C# Página 1 de 2

Clase de conexión e inserción de SQLite C# 2013 Express

por

en febrero 25, 2015

en C#, SQL, SQLITE, visual studio 2013 express

Que tal camaradas.

 

Hace unos días, vimos como conectar C Sharp con SQLite.

image

 

Como corrección en el video anterior, pusimos una librería de SQlite con una versión anterior.

Para corregir esto, solo tenemos que descargar las librerías de SQLite, para la versión de .NET 4.5.

De la misma manera, lo podemos descargar de la pagina oficial, aun así, les dejare en la descripción, las dos paginas, una de Mediafire y otra de la pagina oficial.

Una vez descargada la librería, tenemos que poner los DLL, en la carpeta del proyecto donde se esta generando el ejecutable.

 

 

Ahora veremos la clase conexión.

Primeramente, tenemos que tener en la cabecera el System.data.SQLite.

Después solo ocuparemos 2 líneas, una será para acceder al archivo que es la variable SQLCON y la otra para hacer las consultas en el archivo que seria el SQLCMD.

Con este ultimo haremos una función, con el cual le mandaremos a travez de una cadena la consulta que deseamos realizar en la base de datos.

En, SQLCON, ponemos la cadena de conexión, alli pondremos el lugar donde esta el archivo de la base de datos, que es donde se genera el ejecutable. 

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.Threading.Tasks;

   6: using System.Data.SQLite; 

   7:  

   8: namespace LECTOR_CFDI.Clases

   9: {

  10:     

  11:  

  12:     

  13:     //Classe para hacer la conexion y ejecutar querys

  14:     class classConexion

  15:     {

  16:         //VARIABLES QUE USAREMOS

  17:         SQLiteConnection SQLcon = new SQLiteConnection("Data Source=|DataDirectory|facturas.s3db;");

  18:         SQLiteCommand SQLcmd;

  19:  

  20:     public void ejecutar(string strConsulta){

  21:         SQLcon.Open();  

  22:         SQLcmd= new SQLiteCommand (strConsulta,SQLcon);

  23:         SQLcmd.ExecuteNonQuery();

  24:     }

  25:     }

  26:   

  27: }

 

 

Luego en la clase complemento, hacemos la función guardar, que tendrá la consulta para insertar los datos en la base de datos. 

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.Threading.Tasks;

   6: using LECTOR_CFDI.Clases;

   7:  

   8: namespace LECTOR_CFDI.Clases

   9: {

  10:     class classComplemento

  11:     {

  12:         public string strUUID;

  13:         public string strSelloSat;

  14:         public string strNoCertificadoSat;

  15:         public string strSelloCFD;

  16:         public string strFechaTimbrado;

  17:         public string strVersion;

  18:         

  19:         public void insertar()

  20:         {

  21:             string strQuery;

  22:  

  23:             strQuery = "";

  24:             strQuery = "insert into Complemento values('";

  25:             strQuery = strQuery+strUUID + "','";

  26:             strQuery = strQuery+strFechaTimbrado + "','";

  27:             strQuery = strQuery+strSelloCFD + "','";

  28:             strQuery = strQuery+strNoCertificadoSat + "','";

  29:             strQuery = strQuery+strSelloSat + "','";

  30:             strQuery = strQuery+strVersion + "')";

  31:  

  32:             classConexion con= new classConexion();

  33:  

  34:             con.ejecutar(strQuery);

  35:  

  36:         }

  37:     }

  38: }

Para terminar instanciamos la clase complemento para meterle los datos que necesitamos. 

   1: using System;

   2: using System.Collections.Generic;

   3: using System.ComponentModel;

   4: using System.Data;

   5: using System.Drawing;

   6: using System.Linq;

   7: using System.Text;

   8: using System.Threading.Tasks;

   9: using System.Windows.Forms;

  10: using System.Xml.Serialization;

  11: using System.Xml;

  12: using System.Data.SQLite;

  13: using LECTOR_CFDI.Clases; 

  14:  

  15: namespace LECTOR_CFDI

  16: {

  17:     public partial class Form1 : Form

  18:     {

  19:         string strUUID;

  20:         string strSelloSat;

  21:         string strNoCertificadoSat;

  22:         string strSelloCFD;

  23:         string strFechaTimbrado;

  24:         string strVersion;

  25:         

  26:         public Form1()

  27:         {

  28:             InitializeComponent();

  29:         }

  30:  

  31:         private void button1_Click(object sender, EventArgs e)

  32:         {

  33:             XmlSerializer serielizer = new XmlSerializer(typeof(Comprobante));

  34:             XmlTextReader reader = new XmlTextReader(@"C:xml.xml");

  35:             Comprobante factura = (Comprobante)serielizer.Deserialize(reader);

  36:  

  37:             classConexion bd = new classConexion();  

  38:             

  39:             

  40:             //MessageBox.Show (factura.fecha.ToString());

  41:             classComplemento complemento = new classComplemento();

  42:             complemento.strUUID = (factura.Complemento.Any[0].Attributes[3].Value);

  43:             complemento.strVersion = (factura.Complemento.Any[0].Attributes[2].Value);

  44:             complemento.strFechaTimbrado = (factura.Complemento.Any[0].Attributes[4].Value);

  45:             complemento.strSelloSat = (factura.Complemento.Any[0].Attributes[7].Value);

  46:             complemento.strSelloCFD = (factura.Complemento.Any[0].Attributes[5].Value);

  47:             complemento.strNoCertificadoSat = (factura.Complemento.Any[0].Attributes[6].Value);

  48:             

  49:             complemento.insertar();     

  50:         

  51:         }

  52:         

  53:     }

  54: }

 

Eso es todo por hoy.

Continuamos en el siguiente video donde haremos el mismo ejercicio con los conceptos de la factura y los datos restantes de la factura.

Generar clase C# con XSD

por

en febrero 20, 2015

en C#, CONVERTIR XSD, XSD

Que tal camaradas, Les dejo el siguiente videotutorial donde se mostrara como como generar una clase para C# a partir de un XSD

Espero Les Sirva

El comando es XSD.EXE “RutaDelArchivo”  /C /L:CS

Saludos

CLASE PARA MOSTRAR USUARIO EN DATAGRID

por

en junio 16, 2013

en C#, SQL, SQLITE, VISUAL STUDIO 2012

using System;

using System.Collections.Generic;

using System.Data;

using System.Data.SQLite;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

 

 

namespace Prueba.Clases

{

    class usuarios

    {

 

        public void mostrar(DataGridView dv)

        {

            

            conexion con = new conexion();

            

 

            string sql ="SELECT USUARIO, CONTRA as contraseña FROM USUARIOS";

            SQLiteDataAdapter db = new SQLiteDataAdapter(sql, con.sqlCon);

 

            DataSet ds = new DataSet();

            ds.Reset();

 

            DataTable dt = new DataTable();

            db.Fill(ds);

            dt = ds.Tables[0];

 

            dv.DataSource = dt;

            

            // CERRAMOS LA CONEXION

            con.cerrarConexion();

        }

    }

}

CONEXION CON VISUAL STUDIO 2012 C# CON SQLITE

por

en junio 16, 2013

en C#, SQL, SQLITE, VISUAL STUDIO 2012

/*JULIO CESAR LEYVA RODRIGUEZ 

 * 15 DE JUNIO DE 2013

 */

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data.SQLite;

 

 

namespace Prueba

{

    

    //HACEMOS LA CLASE PARA LA CONEXION

    class conexion

    {

        

        /* HACEMOS LAS VARIABLES DE CONEXION, SE NECESITARAN INSTALAR Y AGREGAR LAS LIBRERIAS DE

         * SQLITE http://www.sqlite.org/download.html

         */

        public SQLiteConnection sqlCon;

        public SQLiteCommand sqlCmd;

 

        public conexion()

        {

            //ESTABLECEMOS LA DIRECCION DEL ARCHIVO DE LA BASE DE DATOS Y ABRIMOS CONEXION

            sqlCon = new SQLiteConnection("Data Source=|DataDirectory|compras.s3db;");

            sqlCon.Open();

        }

        

        //FUNCION PARA CERRAR LA CONEXION

        public void cerrarConexion()

        {

            sqlCon.Close();

        }

 

        //EJECUTA LA CONSULTA QUE SE LE MANDA COMO PARAMETRO

        public void ejecutar(string sql)

        {

            sqlCmd = new SQLiteCommand(sql, sqlCon);

            sqlCmd.ExecuteNonQuery();

        }

 

       

        //FUNCION DE PRUEBA QUE SIRVE DE ACCESO A UN USUARIO

        public bool acceso(string usuario, string cont)

        {

            string  sql = "select * from usuarios where usuario='" + usuario + "' and contra='" + cont + "'";

            sqlCmd = new SQLiteCommand(sql, sqlCon);

            sqlCmd.ExecuteNonQuery();

            bool chekar  = sqlCmd.ExecuteReader().HasRows;

            return chekar;

        }

 

    }

 

}

MANEJO DE ARCHIVOS EN C++

por

en julio 22, 2012

en C#, Cursis C++, Cursos gratuitos C++, MANEJO DE ARCHIVOS C++

3006_c___language_tutorial-png
Otro trabajo que nos dejaron en vacaciones
Ojo poner los archivos con extensión .H en la carpeta INCLUDE de Borland
CONDUCTO.H

   1: /******************************************************************************************************************************
   2:  *                                                                                                                            *
   3:  *                               25 de marzo de 2010                                                                          *
   4:  *                                                                                                                            *
   5:  *                 El programa guarda los datos del conductor en un archivo binario                                           *
   6:  *                                                                                                                            *
   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                 *
   8:  *                                                                                                                            *
   9:  ******************************************************************************************************************************/
  10: #include 
  11: #include 
  12: #include 
  13:  
  14: struct registro
  15: {
  16: int     numeroC;
  17: char     nombre[10];
  18: char     domicilio[20];
  19: float     estatura;
  20: char     activo;
  21: }conductores;
  22:  
  23: void registrarConductor()
  24: {
  25: clrscr();
  26: printf("tt REGISTRO DE CONDUCTORES n");
  27: cout<<"Numero de conductor ";         cin>>conductores.numeroC;   
  28: cout<<"Nombre ";                gets(conductores.nombre);
  29: cout<<"Domicilio ";            gets(conductores.domicilio);
  30: cout<<"Estatura ";            cin>>conductores.estatura;
  31:  
  32: conductores.activo='a';
  33:  
  34: FILE *registro;
  35:  
  36: registro=fopen("conductores.dat","ab");
  37: fwrite(&conductores,sizeof(conductores),1,registro);
  38: fclose(registro);
  39: }
  40:  
  41: void reporteConductores()
  42: {
  43: clrscr();
  44: FILE *rep;
  45:  
  46: rep=fopen("conductores.dat","rb");
  47: fread(&conductores,sizeof(registro),1,rep);
  48: printf("# CONDUCTOR  tt NOMBRE tt DOMICILIO t ESTATURA");
  49:  
  50:     do
  51:     {
  52:     if(conductores.activo=='a')
  53:             {
  54:         cout<<"n"<<conductores.numeroC<<"ttt "<<conductores.nombre<<"ttt "<<conductores.domicilio<<"tt "<<conductores.estatura;
  55:             }
  56:     fread(&conductores,sizeof(registro),1,rep);
  57:     }while(!feof(rep));
  58: fclose(rep);
  59: getch();
  60: }
  61:  
  62: void consultaC(int n)
  63: {
  64: clrscr();
  65: FILE *rep;
  66:  
  67:  
  68: rep=fopen("conductores.dat","rb");
  69:  
  70: fseek(rep,(n-1)*(sizeof(conductores)),SEEK_SET);
  71: fread(&conductores,(n)*(sizeof(conductores)),1,rep);
  72:  
  73: printf("# CONDUCTOR  tt NOMBRE tt DOMICILIO t ESTATURA");
  74: if(conductores.activo=='a')
  75:     {
  76:     cout<<"n"<<conductores.numeroC<<"ttt "<<conductores.nombre<<"ttt "<<conductores.domicilio<<"tt "<<conductores.estatura;
  77:         }
  78: else
  79:     {
  80:     cout<<"n El conductor no exite";
  81:         }
  82: fclose(rep);
  83: }
  84:  
  85:  
  86:  
  87: void eliminarC()
  88: {
  89: FILE *reg;
  90: int d;
  91:  
  92: cout<<"Inserte el conductor que desee dar de baja: ";    cin>>d;
  93:  
  94: reg=fopen("conductor.dat","rb+");
  95:  
  96: fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);
  97: fread(&conductores,(d)*(sizeof(conductores)),1,reg);
  98:  
  99:  
 100: conductores.activo='b';
 101:  
 102: fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);
 103: fwrite(&conductores,sizeof(conductores),1,reg);
 104: fclose(reg);
 105: }
 106:  
 107:  
 108: void menuC()
 109: {
 110: conductores.activo=NULL;
 111: int op;
 112: int b;
 113: while(op!=5)
 114:     {
 115:     clrscr();
 116:     gotoxy(25,1);    cout<<"REGISTRO DE CONDUCTORES";
 117:     gotoxy(1,3);    cout<<"1.- Registrar conductor";
 118:     gotoxy(1,5);    cout<<"2.- Reporte";
 119:     gotoxy(1,7);    cout<<"3.- Consulta";
 120:     gotoxy(1,9);    cout<<"4.- Eliminar";
 121:     gotoxy(1,11);    cout<<"5.- Regresar";
 122:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";
 123:     gotoxy(24,14);    cin>>op;
 124:  
 125:     switch(op)
 126:                 {
 127:         case 1:
 128:             registrarConductor();
 129:                         
 130:             break;
 131:         case 2:        
 132:             reporteConductores();
 133:                         break;
 134:         case 3:               
 135:             clrscr();
 136:             cout<<"Inserte el numero de conductor que desee consultar ";    cin>>b;
 137:             consultaC(b);
 138:                         getch();
 139:             break;
 140:         case 4:
 141:             clrscr();
 142:                         eliminarC();
 143:                 break;
 144:  
 145:         }
 146:     }
 147: }
 148: void eslogan()
 149: {
 150: cout<<"   ******      **     *******   *******   ******** *******       **    ";
 151: cout<<"n  **////**    ****   /**////** /**////** /**///// /**////**     ****   ";
 152: cout<<"n **    //    **//**  /**   /** /**   /** /**      /**   /**    **//**  ";
 153: cout<<"n/**         **  //** /*******  /*******  /******* /*******    **  //** ";
 154: cout<<"n/**        **********/**///**  /**///**  /**////  /**///**   **********";
 155: cout<<"n//**    **/**//////**/**  //** /**  //** /**      /**  //** /**//////**";
 156: cout<<"n //****** /**     /**/**   //**/**   //**/********/**   //**/**     /**";
 157: cout<<"n  //////  //      // //     // //     // //////// //     // //      // ";
 158: }
 159: 

AUTOMOVI.H

   1: /************************************************************************************************************
   2:  *                                                                                                          *
   3:  *                                              25 DE MARZO DE 2010                                         *
   4:  *                                                                                                          *
   5:  *  Programa que almacena los datos de los diferentes tipos de carros y los guarda en un archivo binario    *
   6:  *                                                                                                          *
   7:  *  Programador Julio Cesar Leyva Rodriguez            Instituto Tecnologico de Los Mochis                  *
   8:  *                                                                                                          *
   9:  ************************************************************************************************************/
  10:                                           
  11: #include 
  12: #include 
  13: #include  
  14: #include 
  15:  
  16: /** Estructura de los datos de los datos */
  17: struct reg
  18: {
  19: int numeroV;
  20: char marca[10];
  21: int anio;
  22: char color[10];
  23: int matricula;
  24: char activo;
  25: }automoviles;
  26:  
  27:  
  28: /** Funcion para registrar los datos en el archivo */
  29: void registrar()
  30: {
  31:  
  32: clrscr();
  33: printf("tt REGISTRO DE AUTOS n");
  34: cout<<"Numero de vehiculo ";         cin>>automoviles.numeroV;
  35: cout<<"Marca ";                    gets(automoviles.marca);
  36: cout<<"Año ";                cin>>automoviles.anio;
  37: cout<<"Matricula ";                     cin>>automoviles.matricula;
  38: cout<<"Color ";                gets(automoviles.color);
  39:  
  40: automoviles.activo='a';              //Marca que el archivo no esta eliminado logicamente
  41:  
  42:  
  43: FILE *registro1;
  44:  
  45: registro1=fopen("automoviles.dat","ab+");
  46: fseek(registro1,(automoviles.numeroV)-1*(sizeof(automoviles)),SEEK_SET);     //Posicionar el puntero en un lugar definido por la variable vehiculoV
  47: fwrite(&automoviles,sizeof(automoviles),1,registro1);                        //Escrive en el archivo
  48: fclose(registro1);
  49:  
  50: }
  51:  
  52: /** Muestra todos los registros del archivo en forma de reporte */
  53: void reporte()
  54: {
  55: clrscr();
  56: FILE *rep;
  57:  
  58: rep=fopen("automoviles.dat","rb+");
  59: fread(&automoviles,sizeof(automoviles),1,rep);
  60: printf("# VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");
  61:  
  62:     do
  63:     {
  64:     if(automoviles.activo=='a')
  65:         {
  66:         cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;
  67:         }
  68:     fread(&automoviles,sizeof(automoviles),1,rep);
  69:     }while(!feof(rep));
  70: fclose(rep);
  71: getch();
  72: }
  73:  
  74: /** Consulta un solo registro en el archivo */
  75: void consultaVehiculo(int n)
  76: {
  77: FILE *rep;
  78:  
  79:  
  80:  
  81: rep=fopen("automoviles.dat","rb");
  82:  
  83: fseek(rep,(n-1)*(sizeof(automoviles)),SEEK_SET);
  84: fread(&automoviles,(n)*(sizeof(automoviles)),1,rep);
  85:  
  86: printf("n # VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");
  87: if(automoviles.activo=='a')
  88:     {
  89:     cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;
  90:     }
  91: else
  92:     {
  93:     cout<<"n El automovil no existe";
  94:     }
  95: fclose(rep);
  96: }
  97:  
  98: /* Modifica un registro señalado */
  99: void modificar()
 100: {
 101: clrscr();
 102: FILE *reg;
 103: int d;
 104:  
 105: cout<<"Inserte el dato que desee modificar: ";    cin>>d;
 106:  
 107: reg=fopen("automoviles.dat","rb+");
 108:  
 109: printf("tt REGISTRO DE AUTOS n");
 110: cout<<"Numero de vehiculo ";     cin>>automoviles.numeroV;
 111: cout<<"Marca ";                gets(automoviles.marca);
 112: cout<<"Año ";            cin>>automoviles.anio;
 113: cout<<"Matricula ";        cin>>automoviles.matricula;
 114: cout<<"Color ";            gets(automoviles.color);
 115:  
 116: automoviles.activo='a';
 117:  
 118: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);
 119: fwrite(&automoviles,sizeof(automoviles),1,reg);
 120: fclose(reg);
 121: }
 122:  
 123: /* Elimina el registro seleccionado "logicamente" */
 124: void eliminar()
 125: {
 126: FILE *reg;
 127: int d;
 128:  
 129: cout<<"Inserte el registro que desee Eliminar: ";    cin>>d;
 130:  
 131: reg=fopen("automoviles.dat","rb+");
 132:  
 133: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);
 134: fread(&automoviles,(d)*(sizeof(automoviles)),1,reg);
 135:  
 136:  
 137: automoviles.activo='b';
 138:  
 139: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);
 140: fwrite(&automoviles,sizeof(automoviles),1,reg);
 141: fclose(reg);
 142: }
 143:  
 144:  
 145: /* Menu de opciones */
 146: void menuA()
 147: {
 148: int a;
 149: int op;
 150: while(op!=5)
 151:         {
 152:     automoviles.activo=NULL;
 153:         clrscr();
 154:     gotoxy(25,1);    cout<<"REGISTRO DE AUTOMOTORES";
 155:     gotoxy(1,3);    cout<<"1.- Registrar automotor";
 156:     gotoxy(1,5);    cout<<"2.- Reporte";
 157:     gotoxy(1,7);    cout<<"3.- Consultar";
 158:     gotoxy(1,9);    cout<<"4.- Eliminar";
 159:         gotoxy(1,11);    cout<<"5.- Regresar";
 160:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";
 161:     gotoxy(23,14);    cin>>op;
 162:     cout<<"n";
 163:         eslogan();
 164:  
 165:     switch(op)
 166:                 {
 167:         case 1:
 168:             registrar();
 169:                         
 170:             break;
 171:         case 2:
 172:             reporte();                        
 173:                         break;
 174:         case 3:               
 175:             clrscr();
 176:                  cout<<"Inserte el numero de automovil que desee consultar";    cin>>a;    
 177:             consultaVehiculo(a);                      
 178:                         getch();
 179:             break;
 180:         case 4:
 181:             clrscr();
 182:                         eliminar();
 183:                 break;
 184:  
 185:         }
 186:     }
 187: }
 188: 

EVENTO.H

   1: /******************************************************************************************************************************
   2:  *                                                                                                                            *
   3:  *                               25 de marzo de 2010                                                                            *
   4:  *                                                                                                                            *
   5:  *        Elprograma graba el folio y el numero de conductor y vechiculo para consultar sus datos y registrar sus tiempo         *                                          *
   6:  *                                                                                                                            *
   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                   *
   8:  *                                                                                                                            *
   9:  ******************************************************************************************************************************/
  10: #include 
  11:  
  12: struct evento
  13: {
  14: int folio;
  15: int nC;
  16: int nV;
  17: int tiempo;
  18: }carrera;
  19:  
  20:  
  21:  
  22: void ultimo();
  23:  
  24:  
  25: void borrar()
  26: {
  27: carrera.folio=NULL;
  28: carrera.nC=NULL;
  29: carrera.nV=NULL;
  30: carrera.tiempo=NULL;
  31: }
  32: //REGISTRAR AUTO Y CONDUCTOR
  33:  
  34: void registrarParticipante()
  35: {
  36:  
  37: borrar();
  38: FILE *e;
  39: FILE *a;
  40: int size;
  41:  
  42: borrar();
  43: e=fopen("evento.dat","ab+");
  44: a=fopen("evento.dat","rb+");
  45:  
  46:  
  47: size=sizeof(carrera);
  48:  
  49: fseek(a,-size,SEEK_END);
  50: fread(&carrera,size,1,a);
  51:  
  52: carrera.tiempo=NULL;
  53: carrera.folio=(carrera.folio)+1;
  54:  
  55: cout<<"nINSERTE EL NUMERO DEL PILOTO ";    cin>>carrera.nC;
  56:  
  57: cout<<"nINSERTE EL NUMERO DEL VEHICULO ";    cin>>carrera.nV;
  58:  
  59: fwrite(&carrera,sizeof(carrera),1,e);
  60:  
  61: fclose(e);
  62: fclose(a);
  63:  
  64: }
  65:  
  66:  
  67:  
  68: //ULTIMO REGISTRO
  69:  
  70: void ultimo()
  71: {
  72: FILE *final;
  73:  
  74: borrar();
  75: final=fopen("evento.dat","ab+");
  76:  
  77: do
  78:     {
  79:     fread(&carrera,sizeof(carrera),1,final);
  80:     }while(!feof(final));
  81:  
  82: }
  83:  
  84: //REPORTE
  85:  
  86: void reporteEvento()
  87: {
  88: borrar();
  89: FILE *reporte1;
  90:  
  91: reporte1=fopen("evento.dat","rb+");
  92:  
  93: do
  94:     {
  95:         if(carrera.folio!=NULL)
  96:             {
  97:             cout<<"n"<<"FOLIO "<<carrera.folio<<" NUMERO DE VEHICULO "<<carrera.nV<<" NUMERO DE CONDUCTOR "<<carrera.nC<<" TIEMPO "<<carrera.tiempo ;
  98:             }
  99:     fread(&carrera,sizeof(carrera),1,reporte1);
 100:     }while(!feof(reporte1));
 101: }
 102:  
 103:  
 104:  
 105: void registrarTiempo()
 106: {
 107: FILE *tiempo;
 108: tiempo=fopen("evento.dat","rb+");
 109: int folio;
 110:  
 111: borrar();
 112: cout<<"nnINSERTE EL FOLIO DEL PILOTO QUE DESEE INGRESAR EL TIEMPO ";
 113: cin>>folio;
 114:  
 115: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);
 116: fread(&carrera,sizeof(carrera),1,tiempo);
 117:  
 118: cout<<"nnINGRESE EL TIEMPO ";cin>>carrera.tiempo;
 119:  
 120: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);
 121: fwrite(&carrera,sizeof(carrera),1,tiempo);
 122: fclose(tiempo);
 123: }
 124:  
 125:  
 126: /* Menu de opciones */
 127: void menuE()
 128: {
 129: int a;
 130: int op;
 131: while(op!=5)
 132:     {
 133:     automoviles.activo=NULL;
 134:     clrscr();
 135:     gotoxy(25,1);    cout<<"EVENTO";
 136:     gotoxy(1,3);    cout<<"1.- Registrar participante";
 137:     gotoxy(1,5);    cout<<"2.- Reporte";
 138:     gotoxy(1,7);    cout<<"3.- Modificar tiempo";
 139:     gotoxy(1,9);    cout<<"4.- Consulta participante";
 140:     gotoxy(1,11);    cout<<"5.- Regresar";
 141:     gotoxy(1,13);    cout<<"t Eliga una opcion [   ]";
 142:     gotoxy(26,13);    cin>>op;
 143:  
 144:     switch(op)
 145:         {
 146:         case 1:
 147:             clrscr();
 148:             registrarParticipante();
 149:             getch();
 150:             break;
 151:         case 2:
 152:             reporteEvento();
 153:             getch();
 154:             break;
 155:         case 3:
 156:             clrscr();
 157:             registrarTiempo();
 158:             getch();
 159:             break;
 160:  
 161:         case 4:
 162:             cout<<"n INSERTE EL NUMERO DEL PARTICIPANTE QUE DESEE CONSULTAR ";     cin>>a;
 163:             consultaVehiculo(a);
 164:             cout<<"n";
 165:             getch();
 166:             consultaC(a);
 167:             cout<<"nPresione cualquier tecla para continuar";
 168:             getch();
 169:             break;
 170:         case 5:
 171:                     break;
 172:         default:
 173:             cout<<"OPCION NO VALIDA";
 174:             getch();
 175:             break;
 176:         }
 177:     }
 178: }
 179: 

VACACION.CPP

   1: /******************************************************************************************************************************
   2:  *                                                                                                                            *
   3:  *                                   11 de abril de 2010                                                                      *
   4:  *                                                                                                                            *
   5:  *                 Paquete de programas para el proyecto de la carrera                                                        *
   6:  *                                                                                                                            *
   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                 *
   8:  *                                                                                                                            *
   9:  ******************************************************************************************************************************/
  10: #include 
  11: #include 
  12: #include 
  13: #include 
  14:  
  15:  
  16: void main()
  17: {
  18: int op;
  19: while(op!=4)
  20:     {
  21:     clrscr();
  22:     eslogan();
  23:     gotoxy(25,15);    cout<<"PRINCIPAL";
  24:     gotoxy(1,18);    cout<<"1.- Vehiculos";
  25:     gotoxy(1,20);    cout<<"2.- Conductores";
  26:     gotoxy(1,22);    cout<<"3.- Evento";
  27:     gotoxy(1,24);    cout<<"4.- Salir";
  28:     gotoxy(1,26);    cout<<"t Eliga una opcion [   ]";
  29:     gotoxy(22,26);    cin>>op;
  30:  
  31:     switch(op)
  32:         {
  33:         case 1:
  34:             clrscr();
  35:             menuA();
  36:  
  37:             break;
  38:         case 2:
  39:             menuC();                        
  40:                         break;
  41:         case 3:               
  42:             clrscr();
  43:             menuE();
  44:             break;
  45:         case 4:
  46:             clrscr();
  47:             break;
  48:         case 5:
  49:             cout<<"nOPCION INCORRECTA";
  50:             break;
  51:  
  52:         }
  53:     }
  54: }

Simulación en C++

por

en junio 29, 2012

en C#, Simulacion, Simulacion en C++

SIMULACION EN C++

DESCARGAR CODIGO FUENTE COMPLETO

DESCARGAR CABECERA
Este archivo va en la carpeta INCLUDE

 
SIMULA.CPP
 
   1: #include 

   2: #include 

   3: #include 

   4:  

   5: typedef struct simulacion

   6: {

   7: int tiemposimulacion;

   8: int tiemposervicio;

   9: int probabilidad;

  10:  

  11: int relog;

  12:  

  13: int cajero;

  14:  

  15: int tiemposerviciototal;

  16: int clientesatendidos;

  17: };

  18:  

  19: void parametros(simulacion *p);

  20: int aleatorio(simulacion *a)

  21: {

  22: int x;

  23: float y;

  24: randomize();

  25: y=random(100);

  26: y=y*3.1416;

  27: x=y;

  28: y=y-x;

  29: y=y*100;

  30: if(a->probabilidad<=y)

  31:     {

  32:     return(1);

  33:     }

  34: else

  35:     {

  36:     return(0);

  37:     }

  38: }

  39:  

  40:  

  41: void llegacliente(cola *c)

  42: {

  43: if(aleatorio<=aleatorio)

  44:     {

  45:     push(c);

  46:     }

  47: }

  48:  

  49: void enmarcha(simulacion *e, cola *c)

  50: {

  51: inicializarcola(c);

  52: e->relog=0;

  53: e->cajero=0;

  54: e->clientesatendidos=0;

  55: e->tiemposerviciototal=0;

  56: int v=0;

  57: clrscr();

  58:  

  59: while(e->relog!=e->tiemposimulacion+1)

  60:     {

  61:     clrscr();

  62:     for(int v=0; v<max; v++)

  63:         {

  64:         *(c->cola+v)=*(c->cola+v)+1;

  65:         }

  66:     gotoxy(1,1);    cout<<"Minutos trancurridos: "<relog;

  67:     (e->relog)++;

  68:  

  69:     gotoxy(40,1);    cout<<"Probabilidad "<probabilidad;

  70:  

  71:     gotoxy(1,20);    cout<<"Clientes atendidos "<clientesatendidos;

  72:  

  73:     gotoxy(40,20);    cout<<"Tiempo de espera total "<tiemposerviciototal;

  74:     if(aleatorio(e)==0)

  75:         {

  76:         insertar(c);

  77:         for(int v=0; v<30; v++)

  78:             {

  79:             gotoxy(1,3);    cout<<"Ha llegado un cliente";

  80:             }

  81:         }

  82:  

  83:     if(e->cajero==0)

  84:         {

  85:         gotoxy(1,4);    borrar(c);

  86:         e->cajero=e->tiemposervicio;

  87:         }

  88:     (e->cajero)--;

  89:  

  90:  

  91:     if(e->cajero==0 && colavacia(c)==0)

  92:         {

  93:         (e->clientesatendidos)++;

  94:         e->tiemposerviciototal=e->tiemposerviciototal+*(c->cola+c->frente);

  95:         }

  96:  

  97:     getch();

  98:     }

  99: }

 100:  

 101:  

 102:  

 103: main()

 104: {

 105: clrscr();

 106: cola fila;

 107: tipodatocola colas[max];

 108: fila.cola=&colas[0];

 109:  

 110: simulacion simula;

 111: parametros(&simula);

 112: enmarcha(&simula, &fila);

 113: }

 114:  

 115:  

 116:  

 117:  

 118: void parametros(simulacion *p)

 119: {

 120: cout<<"Tiempo de duracion de la simulacion: ";            cin>>p->tiemposimulacion;

 121: cout<<"Tiempo limite del servicio del servidor: ";        cin>>p->tiemposervicio;

 122: cout<<"probabilidad de llegada de un cliente en un minuto ";    cin>>p->probabilidad;

 123: }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

 

COLAS.H

   1: //COLAS

   2: //JULIO CESAR LEYVA RODRIGUEZ

   3: #include 

   4: #include 

   5: #define max 100

   6: typedef int tipodatocola;

   7: typedef struct cola

   8: {

   9: tipodatocola *cola;                             

  10: int frente;

  11: int final;

  12: int contador;

  13: };

  14:  

  15: //INICIALIZAR COLA

  16: void inicializarcola(cola *inicializar)

  17: {

  18: inicializar->frente=max-1;

  19: inicializar->final=-1;

  20: gotoxy(40,5);    cout<<"SE HA INICIALIZADO LA COLA";

  21: }

  22:  

  23: //COLA LLENA

  24: int colallena(cola *llena)

  25: {

  26: if(llena->final==llena->frente-1)

  27:     {

  28:     return(1);

  29:     }

  30: else

  31:     {

  32:     return(0);

  33:     }

  34: }

  35:  

  36: //COLA VACIA

  37: int colavacia(cola *v)

  38: {

  39: if((v->frente==v->final) || (v->final==-1 && v->frente==max-1))

  40:     {

  41:         return(1);

  42:     }

  43: else

  44:     {

  45:     return(0);

  46:         }

  47: }

  48:  

  49: void push(cola *z)

  50: {

  51: if(z->final==max-1)

  52:     {                       

  53:     (z->final)=-1;

  54:     *(z->cola+z->final+1)=0;

  55:     }          

  56: else

  57:     {                                                                      

  58:     (z->final)++;

  59:         *(z->cola+z->final)=0;

  60:         }

  61: }

  62:  

  63: void insertar(cola *i)

  64: {

  65: tipodatocola cliente;

  66: if(colallena(i)==1)

  67:     {            

  68:     cout<<"La cola esta llena";

  69:     }

  70: else

  71:     {

  72:     push(i);

  73:     }

  74: }        

  75:  

  76: tipodatocola pop(cola *c)

  77: {

  78: tipodatocola dato;

  79: if(c->frente==max-1 && c->final>-1)

  80:     {       

  81:     c->frente=0;

  82:     dato=*(c->cola+c->frente);

  83:     return(dato);

  84:     }

  85: else                             

  86:     {

  87:     c->frente=c->frente+1;

  88:     dato=*(c->frente+c->cola);

  89:     return(dato);

  90:         }

  91: }

  92:  

  93: void borrar(cola *borrar)

  94: {

  95: if(colavacia(borrar)==1)

  96:     {

  97:     cout<<"La cola esta vacia";

  98:     }

  99: else

 100:     {

 101:     cout<<"El cliente a pasado al cajero con "<<pop(borrar)<<" minutos de espera";

 102:     }

 103: }

 104:  

 105: void visualizarcola(cola *v)

 106: {

 107: if(colavacia(v)==1)

 108:     {

 109:     cout<<"No hay datos";

 110:     }

 111: else

 112:     {

 113:     for(int x=v->frente; xfinal; x++)

 114:         {

 115:         if(x==max-1)

 116:             {

 117:             x=0;

 118:                         }

 119:         gotoxy(x+20,25);    cout<cola+1;

 120:         }

 121:         }

 122:  

 123: }    

 124:       

 125:  

 126:  

 127:  

 128: //MENU

 129: void menu(cola *menu) 

 130: {                                                      

 131: int op;

 132: do

 133:  

 134:     {

 135:     clrscr();

 136:     cout<<"Frente "<frente;

 137:         cout<<"nFinal "<final;

 138:         cout<<"nCola "<cola+menu->frente);

 139:      gotoxy(1,5);    cout<<"MENU";

 140:     gotoxy(1,6);    cout<<"1. INICIALIZAR";

 141:     gotoxy(1,7);    cout<<"2. INSERTAR";

 142:     gotoxy(1,8);    cout<<"3. BORRAR";

 143:     gotoxy(1,9);    cout<<"ELIGA UNA OPCION [   ]";

 144:     gotoxy(20,9);    cin>>op;

 145:     switch(op)

 146:         {

 147:         case 1:

 148:             inicializarcola(menu);

 149:             getch();

 150:             break;

 151:         case 2:

 152:             insertar(menu);

 153:             getch();

 154:             break;

 155:         case 3:

 156:                 borrar(menu);

 157:             getch();

 158:                         break;

 159:         case 4:

 160:             visualizarcola(menu);

 161:             getch();

 162:                         break;

 163:         }

 164:     }

 165:     while(op!=5);

 166: }

 167: 

Pilas en C++

por

en junio 29, 2012

en C#, Pilas, Pilas en C++

   1: //PILAS

   2:  

   3: #include 

   4: #include 

   5: #include 

   6: #define max 5

   7:  

   8: typedef int tipodatopila;

   9:                          

  10: tipodatopila pila[max];

  11: int tope;

  12:  

  13: void visualizarpila(tipodatopila *pila);

  14: void inicializarpila(int *tope);

  15: void menu(int *tope, tipodatopila *pila);

  16: int pilavacia(int *tope);

  17: int pilallena(int *tope);

  18: void push(int *tope, tipodatopila *pila, tipodatopila *dato);

  19: void alta(int *tope);

  20: tipodatopila pop(int *tope, tipodatopila *pila)

  21: {

  22: tipodatopila b=*(tope)+*(pila);

  23: *(tope)=*(tope)-1;

  24: return(b);

  25:  

  26: }

  27: void baja(int *tope, tipodatopila *pila)

  28: {

  29: if(pilavacia(tope)==1)

  30:     {

  31:     gotoxy(40,4);    cout<<"LA PILA ESTA VACIA";

  32:     }                              

  33: else

  34:     {

  35:     gotoxy(40,4);    cout<<"EL DATO ELIMINADO FUE "<<pop(tope,pila);

  36:     }

  37: }

  38:                   

  39:  

  40: main()

  41: {

  42: menu(&tope,&pila[0]);

  43: }

  44:  

  45: void menu(int *tope, tipodatopila *pila)

  46: {

  47: int op;

  48:  

  49: do

  50:     {

  51:         clrscr();

  52:         gotoxy(10,10);    visualizarpila(pila);

  53:     gotoxy(30,2);     cout<<"PILAS";

  54:     gotoxy(10,4);     cout<<"1. INICIALIZAR PILA";

  55:     gotoxy(10,5);     cout<<"2. ALTA";

  56:     gotoxy(10,6);     cout<<"3. BAJA";

  57:     gotoxy(10,7);     cout<<"4. SALIR";

  58:     gotoxy(10,8);     cout<<"ELIGA UNA OPCION [   ]";

  59:     gotoxy(29,8);    cin>>op;

  60:     switch(op)

  61:         {

  62:         case 1:

  63:             inicializarpila(tope);

  64:             break;

  65:            case 2:

  66:             alta(tope);

  67:                         getch();

  68:             break;

  69:         case 3:

  70:                         baja(tope,pila);

  71:             getch();

  72:             break;

  73:         case 4:

  74:                         clrscr();

  75:             cout<<"ADIOS ;D";

  76:             getch;

  77:             break;                      

  78:  

  79:         default:

  80:             cout<<"HAZ TECLADO UNA LETRA";

  81:                         break;   

  82:  

  83:         }

  84:                 

  85:     }while(op!=4); 

  86:  

  87: }

  88:  

  89:  

  90:  

  91:  

  92:  

  93:  

  94:  

  95:  

  96:  

  97:  

  98:  

  99:  

 100:  

 101:  

 102:  

 103:  

 104:  

 105:  

 106:  

 107:  

 108:  

 109: int pilallena(int *tope)

 110: {

 111: if(*(tope)==max-1)

 112:     {

 113:     return(1);

 114:     }

 115: else

 116:     {

 117:     return(0);

 118:     }

 119: }

 120:  

 121: //Pila vacia

 122: int pilavacia(int *tope)

 123: {

 124: if(*(tope)==-1)

 125:     {

 126:     return(1);

 127:     }

 128: else

 129:     {

 130:     return(0);

 131:     }

 132: }

 133:  

 134:  

 135:  

 136:  

 137:  

 138:  

 139:  

 140: //Funcion inicializar pila

 141: void inicializarpila(int *tope)

 142: {

 143: *(tope)=-1;

 144: }

 145:  

 146: //Visualizar pila

 147: void visualizarpila(tipodatopila *pila)

 148: {

 149: for(int f=0; f<max; f++)

 150:     {

 151:     cout<<"n"<<*(pila+f);

 152:     }

 153: }

 154:  

 155: void push(int *tope, tipodatopila *pila, tipodatopila *dato)

 156: {

 157: *(tope)=*(tope)+1;

 158: *(pila+*tope)=*dato;

 159: }

 160:  

 161: void alta(int *tope)

 162: {

 163: tipodatopila dato;

 164: if(pilallena(tope)==1)

 165:     {

 166:     gotoxy(40,4);    cout<<"LA PILA ESTA LLENA";

 167:     }

 168: else

 169:     {

 170:     gotoxy(40,5);    cout<<"INSERTE EL DATO ";    cin>>dato;

 171:     gotoxy(40,6);    push(tope,pila,&dato);

 172:     }

 173: }

 

Generar numeros aleatorios C++

por

en junio 29, 2012

en C#, numeros aleatorios sin repetir

 
   1: //GENERAR NUMEROS ALEATORIOS SIN DUPLICADOS

   2: #include 

   3: #include 

   4: #include 

   5:  

   6: int x;               

   7: int y;

   8: int na;                                

   9: int a[10];

  10: int z;

  11:  

  12: main()

  13: {

  14: randomize();

  15: while(x<10)

  16:     {

  17:         int c=0;

  18:     na=random(10);

  19:     for(y=0; y<10; y++)

  20:         {

  21:         if(na==a[x])

  22:             {

  23:             c++;

  24:             }

  25:         }

  26:     if(c==0)

  27:         {

  28:         a[x]=na;

  29:         x++;

  30:                 }

  31:     else

  32:         {

  33:         na=random(10);

  34:                 }

  35:     }

  36: for(z=0; z<10; z++)

  37:     {

  38:         cout<<"n"<<a[z];

  39:         }

  40: }

Apuntadores con funciones en C++

por

en junio 29, 2012

en Appuntadores con funciones C++, Apuntadores, Apuntadores C++, C#, Funciones, Funciones C++

Les dejo el archivo para descargar.

APUNTADO.CPP
   1:

   2:

   3: //JULIO CESAR LEYVA RODRIGUEZ

   4:

   5: //APUNTADORES CON FUNCIONES

   6:

   7:

   8:

   9: #include

  10: #include

  11: #include

  12: #include

  13:

  14: #define max 5

  15: int arreglo[max];

  16: int x;

  17: int *p;

  18:

  19: void i(int *p)

  20: {

  21:

  22: for(x=0; x<max; x++)

  23:     {

  24:

  25:         *(p+x)=random(9);

  26:

  27:     }

  28: }

  29:

  30:

  31: main()

  32: {

  33: i(&arreglo[0]);

  34: for(x=0; x<max; x++)

  35:     {

  36:     cout<<arreglo[x]<<"n";

  37:         }

  38: }

 

 

Guardar archivos en C++ ejemplo

por

en junio 29, 2012

en Archivos en C++, C#, Ficheros en C++, Guardar archivos en C++

   1: /************************************************************************************************************

   2:  *                                                                                                          *

   3:  *                                              25 DE MARZO DE 2010                                         *

   4:  *                                                                                                            *

   5:  *  Programa que almacena los datos de los diferentes tipos de carros y los guarda en un archivo binario    *

   6:  *                                                                                                          *

   7:  *  Programador Julio Cesar Leyva Rodriguez            Instituto Tecnologico de Los Mochis                     *

   8:  *                                                                                                          *

   9:  ************************************************************************************************************/

  10:                                           

  11: #include 

  12: #include 

  13: #include  

  14: #include 

  15:  

  16: /** Estructura de los datos de los datos */

  17: struct reg

  18: {

  19: int numeroV;

  20: char marca[10];

  21: int anio;

  22: char color[10];

  23: int matricula;

  24: char activo;

  25: }automoviles;

  26:  

  27: void noExiste()

  28: {

  29: cout<<"nEl Registro no existe";

  30: }

  31:  

  32: void espacioOcupado()

  33: {

  34: cout<<"nEspacio ocupado";

  35: }

  36:  

  37: void eliminado()

  38: {

  39: cout<<"nEliminado correctamente";

  40: }

  41:  

  42: void registrado()

  43: {

  44: cout<<"nRegistrado correctamente";

  45: }

  46:  

  47: void registrando()

  48: {

  49: printf("ntt REGISTRO DE AUTOS n");

  50: cout<<"Marca ";                    gets(automoviles.marca);

  51: cout<<"Año ";                cin>>automoviles.anio;

  52: cout<<"Matricula ";                     cin>>automoviles.matricula;

  53: cout<<"Color ";                gets(automoviles.color);

  54: automoviles.activo='a';

  55: }

  56:  

  57:  

  58:  

  59: /** Funcion para registrar los datos en el archivo */

  60: void registrar()                                                        

  61: {

  62: clrscr();

  63:  

  64: FILE *ra;

  65:  

  66: ra=fopen("automoviles.dat","rb+");

  67:  

  68: if(ra==NULL)     //Si no existe

  69:     {

  70:     FILE *n;

  71:         fclose(ra);

  72:     n=fopen("automoviles.dat","ab+");

  73:  

  74:     cout<<"ntINSERTE LOS DATOS DEL PRIMER AUTOn";

  75:         automoviles.numeroV=1;

  76:  

  77:     registrando();

  78:     fwrite(&automoviles,sizeof(automoviles),1,n);

  79:     fclose(n);

  80:         registrado();

  81:     getch();

  82:     }

  83: else

  84:     {

  85:         fclose(ra);

  86:     FILE *c;

  87:  

  88:         c=fopen("automoviles.dat","rb+");

  89:  

  90:         int k;

  91:     cout<<"nInserte el numero de auto que desee insertar ";    cin>>k;

  92:  

  93:     fseek(c,(k-1)*sizeof(automoviles),SEEK_SET);

  94:     fread(&automoviles,sizeof(automoviles),1,c);

  95:  

  96:     if(automoviles.activo==NULL)

  97:         {

  98:         automoviles.numeroV=k;

  99:         registrando();

 100:         fseek(c,(k-1)*sizeof(automoviles),SEEK_SET);

 101:         fwrite(&automoviles,sizeof(automoviles),1,c);

 102:         fclose(c);

 103:         registrado();

 104:         getch();

 105:         }

 106:     else

 107:         {

 108:         espacioOcupado();

 109:                 getch();

 110:         }

 111:         }

 112:  

 113: }

 114:  

 115:  

 116:  

 117:  

 118:  

 119: /** Muestra todos los registros del archivo en forma de reporte */

 120: void reporte()

 121: {

 122: clrscr();

 123: FILE *rep;

 124:  

 125: rep=fopen("automoviles.dat","rb+");

 126: fread(&automoviles,sizeof(automoviles),1,rep);

 127: printf("# VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");

 128:  

 129:     do

 130:     {

 131:     if(automoviles.activo=='a')

 132:         {

 133:         cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;

 134:         }

 135:     fread(&automoviles,sizeof(automoviles),1,rep);

 136:     }while(!feof(rep));

 137: fclose(rep);

 138: getch();

 139: }

 140:  

 141: /** Consulta un solo registro en el archivo */

 142: void consultaVehiculo(int n)

 143: {

 144: FILE *rep;

 145:  

 146:  

 147:  

 148: rep=fopen("automoviles.dat","rb");

 149:  

 150: fseek(rep,(n-1)*(sizeof(automoviles)),SEEK_SET);

 151: fread(&automoviles,sizeof(automoviles),1,rep);

 152:  

 153: if(automoviles.activo!=NULL)

 154:     {

 155:     printf("n # VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");

 156:     if(automoviles.activo=='a')

 157:         {

 158:         cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;

 159:         }

 160:     else

 161:         {

 162:         noExiste();

 163:                 getch();

 164:         }

 165:     }

 166: else

 167:     {

 168:     noExiste();

 169:     getch();

 170:         }

 171: fclose(rep);

 172: }

 173:  

 174: /* Modifica un registro señalado */

 175: void modificar()

 176: {

 177: clrscr();

 178: FILE *reg;

 179: int d;

 180:  

 181: cout<<"Inserte el dato que desee modificar: ";    cin>>d;

 182:  

 183: reg=fopen("automoviles.dat","rb+");

 184:  

 185: printf("tt REGISTRO DE AUTOS n");

 186: cout<<"Numero de vehiculo ";     cin>>automoviles.numeroV;

 187: cout<<"Marca ";                gets(automoviles.marca);

 188: cout<<"Año ";            cin>>automoviles.anio;

 189: cout<<"Matricula ";        cin>>automoviles.matricula;

 190: cout<<"Color ";            gets(automoviles.color);

 191:  

 192: automoviles.activo='a';

 193:  

 194: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 195:  

 196: fwrite(&automoviles,sizeof(automoviles),1,reg);

 197: fclose(reg);

 198: }

 199:  

 200: /* Elimina el registro seleccionado "logicamente" */

 201: void eliminar()

 202: {

 203: FILE *reg;

 204: int d;

 205:  

 206: cout<<"Inserte el registro que desee Eliminar: ";    cin>>d;

 207:  

 208: reg=fopen("automoviles.dat","rb+");

 209:  

 210: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 211: fread(&automoviles,(d)*(sizeof(automoviles)),1,reg);

 212: if(automoviles.activo!=NULL)

 213:         {

 214:     fread(&automoviles,(d)*(sizeof(automoviles)),1,reg);

 215:  

 216:  

 217:  

 218:  

 219:     automoviles.activo='b';

 220:  

 221:     fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 222:     fwrite(&automoviles,sizeof(automoviles),1,reg);

 223:     fclose(reg);

 224:     eliminado();

 225:         getch();

 226:         }

 227: else

 228:     {

 229:     noExiste();

 230:         getch();

 231:         }

 232: }

 233:  

 234:  

 235: /* Menu de opciones */

 236: void menuA()

 237: {

 238: int a;

 239: int op;

 240: while(op!=5)

 241:         {

 242:     automoviles.activo=NULL;

 243:         clrscr();

 244:     gotoxy(25,1);    cout<<"REGISTRO DE AUTOMOTORES";

 245:     gotoxy(1,3);    cout<<"1.- Registrar automotor";

 246:     gotoxy(1,5);    cout<<"2.- Reporte";

 247:     gotoxy(1,7);    cout<<"3.- Consultar";

 248:     gotoxy(1,9);    cout<<"4.- Eliminar";

 249:         gotoxy(1,11);    cout<<"5.- Regresar";

 250:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";

 251:     gotoxy(29,14);    cin>>op;

 252:     cout<<"n";

 253:         eslogan();

 254:  

 255:     switch(op)

 256:                 {

 257:         case 1:

 258:             registrar();

 259:                         

 260:             break;

 261:         case 2:

 262:             reporte();                        

 263:                         break;

 264:         case 3:               

 265:             clrscr();

 266:                  cout<<"Inserte el numero de automovil que desee consultar";    cin>>a;    

 267:             consultaVehiculo(a);                      

 268:                         getch();

 269:             break;

 270:         case 4:

 271:             clrscr();

 272:                         eliminar();

 273:                 break;

 274:  

 275:         }

 276:     }

 277: }

 278:  

 279:  

 280:  

 281: struct registro4

 282: {

 283: int     numeroC;

 284: char     nombre[10];

 285: char     domicilio[10];

 286: float     estatura;

 287: float     peso;

 288: char     activo;

 289: }conductores;

 290:  

 291: void registrandoC()

 292: {

 293:  

 294: printf("ntt REGISTRO DE CONDUCTORES n");

 295: cout<<"Nombre ";                gets(conductores.nombre);

 296: cout<<"Domicilio ";            gets(conductores.domicilio);

 297: cout<<"Estatura ";            cin>>conductores.estatura;

 298: cout<<"Peso ";                cin>>conductores.peso;

 299: conductores.activo='a';

 300: }

 301:  

 302: void registrarConductor()

 303: {

 304: clrscr();

 305:  

 306: FILE *ra;

 307:  

 308: ra=fopen("conductores.dat","rb+");

 309:  

 310: if(ra==NULL)     //Si no existe

 311:     {

 312:     FILE *n;

 313:     fclose(ra);

 314:     n=fopen("conductores.dat","ab");

 315:  

 316:     cout<<"ntINSERTE LOS DATOS DEL PRIMER CONDUCTORn";

 317:     conductores.numeroC=1;

 318:  

 319:     registrandoC();

 320:     fwrite(&conductores,sizeof(conductores),1,n);

 321:     fclose(n);

 322:  

 323:     getch();

 324:     }

 325: else

 326:     {

 327:     fclose(ra);

 328:     FILE *c;

 329:  

 330:     c=fopen("conductores.dat","rb+");

 331:  

 332:     int k;

 333:     cout<<"nInserte el numero de auto que desee insertar ";    cin>>k;

 334:  

 335:     fseek(c,(k-1)*sizeof(conductores),SEEK_SET);

 336:     fread(&conductores,sizeof(conductores),1,c);

 337:  

 338:     if(conductores.domicilio==NULL)

 339:         {

 340:         conductores.numeroC=k;

 341:         fseek(c,(k-1)*sizeof(conductores),SEEK_SET);

 342:         fwrite(&conductores,sizeof(conductores),1,c);

 343:         fclose(c);

 344:  

 345:         getch();

 346:         }

 347:     else

 348:         {

 349:  

 350:         getch();

 351:         }

 352:     }

 353:  

 354: }

 355:  

 356:  

 357:  

 358: void reporteConductores()

 359: {

 360: clrscr();

 361: FILE *rep;

 362:  

 363: rep=fopen("conductores.dat","rb");

 364: fread(&conductores,sizeof(conductores),1,rep);

 365: printf("# CONDUCTOR  t NOMBRE t DOMICILIO t ESTATURAtPESO");

 366:  

 367:     do

 368:     {

 369:     if(conductores.activo=='a')

 370:             {

 371:         cout<<"n"<<conductores.numeroC<<"tt "<<conductores.nombre<<"tt "<<conductores.domicilio<<"tt "<<conductores.estatura<<"tt"<<conductores.peso;

 372:             }

 373:     fread(&conductores,sizeof(conductores),1,rep);

 374:     }while(!feof(rep));

 375: fclose(rep);

 376: getch();

 377: }

 378:  

 379: void consultaC(int n)

 380: {

 381:  

 382: FILE *rep;

 383:  

 384:  

 385: rep=fopen("conductores.dat","rb+");

 386:  

 387: fseek(rep,(n-1)*(sizeof(conductores)),SEEK_SET);

 388: fread(&conductores,sizeof(conductores),1,rep);

 389:  

 390: if(conductores.activo!=NULL)

 391:     {

 392:     printf("# CONDUCTOR  tt NOMBRE tt DOMICILIO t ESTATURA");

 393:     if(conductores.activo=='a')

 394:         {

 395:         cout<<"n"<<conductores.numeroC<<"ttt "<<conductores.nombre<<"ttt "<<conductores.domicilio<<"tt "<<conductores.estatura;

 396:             }

 397:     else

 398:         {

 399:         cout<<"n El conductor no exite";

 400:                 getch();

 401:         }

 402:         

 403:     

 404:     }

 405: else

 406:     {

 407:     cout<<"nEl registro no existe";

 408:     getch();

 409:     }

 410: fclose(rep);  

 411: }

 412:  

 413:  

 414:  

 415: void eliminarC()

 416: {

 417: FILE *reg;

 418: int d;

 419:  

 420: cout<<"Inserte el conductor que desee dar de baja: ";    cin>>d;

 421:  

 422: reg=fopen("conductor.dat","rb+");

 423:  

 424: fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);

 425: fread(&conductores,sizeof(conductores),1,reg);

 426:  

 427: if(conductores.activo!=NULL)

 428:     {

 429:     conductores.activo='b';

 430:  

 431:     fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);

 432:     fwrite(&conductores,sizeof(conductores),1,reg);

 433:     fclose(reg);

 434:     }

 435: else

 436:     {

 437:     cout<<"nEl archivo no esta";

 438:     getch();

 439:         }

 440: }

 441:  

 442:  

 443: void menuC()

 444: {

 445: conductores.activo=NULL;

 446: int op;

 447: int b;

 448: while(op!=5)

 449:     {

 450:     clrscr();

 451:     gotoxy(25,1);    cout<<"REGISTRO DE CONDUCTORES";

 452:     gotoxy(1,3);    cout<<"1.- Registrar conductor";

 453:     gotoxy(1,5);    cout<<"2.- Reporte";

 454:     gotoxy(1,7);    cout<<"3.- Consulta";

 455:     gotoxy(1,9);    cout<<"4.- Eliminar";

 456:     gotoxy(1,11);    cout<<"5.- Regresar";

 457:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";

 458:     gotoxy(29,14);    cin>>op;

 459:  

 460:     switch(op)

 461:                 {

 462:         case 1:

 463:             registrarConductor();

 464:                         

 465:             break;

 466:         case 2:        

 467:             reporteConductores();

 468:                         break;

 469:         case 3:               

 470:             clrscr();

 471:             cout<<"Inserte el numero de conductor que desee consultar ";    cin>>b;

 472:             consultaC(b);

 473:             getch();

 474:             break;

 475:         case 4:

 476:             clrscr();

 477:                         eliminarC();

 478:                 break;

 479:  

 480:         }

 481:     }

 482: }

 483: void eslogan()

 484: {

 485: cout<<"   ******      **     *******   *******   ******** *******       **    ";

 486: cout<<"n  **////**    ****   /**////** /**////** /**///// /**////**     ****   ";

 487: cout<<"n **    //    **//**  /**   /** /**   /** /**      /**   /**    **//**  ";

 488: cout<<"n/**         **  //** /*******  /*******  /******* /*******    **  //** ";

 489: cout<<"n/**        **********/**///**  /**///**  /**////  /**///**   **********";

 490: cout<<"n//**    **/**//////**/**  //** /**  //** /**      /**  //** /**//////**";

 491: cout<<"n //****** /**     /**/**   //**/**   //**/********/**   //**/**     /**";

 492: cout<<"n  //////  //      // //     // //     // //////// //     // //      // ";

 493: }

 494:  

 495:  

 496:  

 497: struct evento

 498: {

 499: int folio;

 500: int nC;

 501: int nV;

 502: int tiempo;

 503: }carrera;

 504:  

 505:  

 506:  

 507: void ultimo();

 508:  

 509:  

 510: void borrar()

 511: {

 512: carrera.folio=NULL;

 513: carrera.nC=NULL;

 514: carrera.nV=NULL;

 515: carrera.tiempo=NULL;

 516: }

 517: //REGISTRAR AUTO Y CONDUCTOR

 518:  

 519: void registrarParticipante()

 520: {

 521:  

 522: borrar();

 523: FILE *e;

 524: FILE *a;

 525: int size;

 526:  

 527: borrar();

 528: e=fopen("evento.dat","ab+");

 529: a=fopen("evento.dat","rb+");

 530:  

 531:  

 532: size=sizeof(carrera);

 533:  

 534: fseek(a,-size,SEEK_END);

 535: fread(&carrera,size,1,a);

 536:  

 537: carrera.tiempo=NULL;

 538: carrera.folio=(carrera.folio)+1;

 539:  

 540: cout<<"nINSERTE EL NUMERO DEL PILOTO ";    cin>>carrera.nC;

 541:  

 542: cout<<"nINSERTE EL NUMERO DEL VEHICULO ";    cin>>carrera.nV;

 543:  

 544: fwrite(&carrera,sizeof(carrera),1,e);

 545:  

 546: fclose(e);

 547: fclose(a);

 548:  

 549: }

 550: //REPORTE

 551:  

 552: void reporteEvento()

 553: {

 554: borrar();

 555: FILE *reporte1;

 556:  

 557: reporte1=fopen("evento.dat","rb+");

 558:  

 559: do

 560:     {

 561:         if(carrera.folio!=NULL)

 562:             {

 563:             consultaVehiculo(carrera.nV);

 564:             consultaC(carrera.nC);

 565:                         }

 566:     fread(&carrera,sizeof(carrera),1,reporte1);

 567:     }while(!feof(reporte1));

 568: }

 569:  

 570:  

 571:  

 572: void registrarTiempo()

 573: {

 574: FILE *tiempo;

 575: tiempo=fopen("evento.dat","rb+");

 576: int folio;

 577:  

 578: borrar();

 579: cout<<"nnINSERTE EL FOLIO DEL PILOTO QUE DESEE INGRESAR EL TIEMPO ";

 580: cin>>folio;

 581:  

 582: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);

 583: fread(&carrera,sizeof(carrera),1,tiempo);

 584:  

 585: cout<<"nnINGRESE EL TIEMPO ";cin>>carrera.tiempo;

 586:  

 587: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);

 588: fwrite(&carrera,sizeof(carrera),1,tiempo);

 589: fclose(tiempo);

 590: }

 591:  

 592:  

 593: /* Menu de opciones */

 594: void menuE()

 595: {

 596: int a;

 597: int op;

 598: while(op!=5)

 599:     {

 600:     automoviles.activo=NULL;

 601:     clrscr();

 602:     gotoxy(25,1);    cout<<"EVENTO";

 603:     gotoxy(1,3);    cout<<"1.- Registrar participante";

 604:     gotoxy(1,5);    cout<<"2.- Reporte";

 605:     gotoxy(1,7);    cout<<"3.- Modificar tiempo";

 606:     gotoxy(1,9);    cout<<"4.- Consulta participante";

 607:     gotoxy(1,11);    cout<<"5.- Regresar";

 608:     gotoxy(1,13);    cout<<"t Eliga una opcion [   ]";

 609:     gotoxy(29,13);    cin>>op;

 610:  

 611:     switch(op)

 612:         {

 613:         case 1:

 614:             clrscr();

 615:             registrarParticipante();

 616:             getch();

 617:             break;

 618:         case 2:

 619:             reporteEvento();

 620:             getch();

 621:             break;

 622:         case 3:

 623:             clrscr();

 624:             registrarTiempo();

 625:             getch();

 626:             break;

 627:  

 628:         case 4:

 629:             cout<<"n INSERTE EL NUMERO DEL PARTICIPANTE QUE DESEE CONSULTAR ";     cin>>a;

 630:             consultaVehiculo(a);

 631:             cout<<"n";

 632:             getch();

 633:             consultaC(a);

 634:             cout<<"nPresione cualquier tecla para continuar";

 635:             getch();

 636:             break;

 637:         case 5:

 638:                     break;

 639:         default:

 640:             cout<<"OPCION NO VALIDA";

 641:             getch();

 642:             break;

 643:         }

 644:     }

 645: }

 646:  

 647:  

 648:  

 649: void main()

 650: {

 651: int op;

 652: while(op!=5)

 653:     {

 654:     clrscr();

 655:     eslogan();

 656:     gotoxy(25,10);    cout<<"PRINCIPAL";

 657:     gotoxy(1,13);    cout<<"1.- Vehiculos";

 658:     gotoxy(1,15);    cout<<"2.- Conductores";

 659:     gotoxy(1,17);    cout<<"3.- Evento";

 660:     gotoxy(1,19);    cout<<"4.- Reporte";

 661:     gotoxy(1,21);    cout<<"t Eliga una opcion [   ]";

 662:     gotoxy(29,21);    cin>>op;

 663:  

 664:     switch(op)

 665:         {

 666:         case 1:

 667:             clrscr();

 668:             menuA();

 669:  

 670:             break;

 671:         case 2:

 672:             menuC();                        

 673:                         break;

 674:         case 3:               

 675:             clrscr();

 676:             menuE();

 677:             break;

 678:         case 4:

 679:             clrscr();

 680:                         reporteEvento();

 681:             getch();

 682:             break;

 683:         case 5:

 684:                         clrscr();

 685:             cout<<"Salir";

 686:                         break;

 687:  

 688:         default:

 689:             cout<<"nOPCION INCORRECTA";

 690:             break;

 691:  

 692:         }

 693:     }

 694: }

Página 1 de 2

Siguiente

Creado con WordPress & Tema de Anders Norén