Herramientas Informaticas

Autor: juliocesar20200413 Página 131 de 141

Desarrollador web apasionado y gusto por la buena musica

CONFIRMAR ELIMINAR UN REGISTRO MYSQL CON PHP

php-logo
Les dejo un script que puede utilizar para confirmar si desea eliminar un registro en la base de datos.

   1: <script type="text/javascript">
   2:         <!--
   3:         function confirmacion(id) {
   4:         var answer = confirm("Esta seguro que desea eliminar")
   5:         if (answer){
   6:         alert("Evento eliminado")
   7:         window.location.href="eliminar.php?ide="+id;
   8:         }
   9:         else{
  10:         alert("Cancelado")
  11:         }
  12:     }    
  13: //-->
  14: 

Al momento de utilizarlo quedaría de esta forma.

   1: <?php
   2: ......
   3: echo " ";
   4: .......
   5: ?>

ENVIAR UN CORREO CON PHP

php-logo
Un pequeño script que hice para una sola ocasión, se los dejo para que lo modifiquen y lo usen de acuerdo a sus necesidades.

   1: <?php
   2: //FUNCION QUE ENVIA UN CORREO ELECTRONICO
   3:  function enviar_correo($correo_e,$nombre,$asunto,$edificio,$dia,$mes,$anio,$hora,$minuto)
   4:     {
   5:     $headers = "MIME-Version: 1.0n";
   6:     $headers .= "Content-type: text/html; charset=utf-8n";
   7:     $headers .= "From: no-reply n";
   8:     $headers .= "X-Mailer: PHP/" . phpversion();
   9:     
  10:     $mensaje="Estimado $nombre se ha registrado su prestamo para el $dia de $mes del $anio a las $hora : $minuto";
  11:     mail($correo_e,$asunto,$mensaje,$headers);
  12:     }
  13:  ?>

DESCARGAR CODIGO FUENTE

Script para conectar PHP con Mysql

php-logo
Les dejo un código que hice hace unos meses, lo hice para hacer eso de la conexión en una sola línea y no andar perdiendo tiempo
Son dos funciones hasta ahora, una para conectar y otra para desconectar,he pensado hacer el de liberar resultados entre otros pero aun no le veo ventaja.
A veces es necesario hacer esto para ahorrar tiempo, cuando utilizas muchas veces la misma conexión.

   1: <?php
   2: /*******************************************************************************************************************
   3: *                             DESCRIPCION: ESTE ARCHIVO TIENE LA FUNCION DE CONECTAR CON LA BASE DE DATOS.             *
   4: *                             PROGRAMADOR: JULIO CESAR LEYVA RODRIGUEZ.                                               *
   5: *                             FECHA:          01/07/2012                                                               *
   6: ********************************************************************************************************************/
   7:  
   8: function conectar_mysql($direccion,$usuario,$password,$basededatos)
   9:     {
  10:     global $enlace;
  11:     if(!($enlace=mysql_connect($direccion,$usuario,$password)))
  12:         {
  13:         echo " alert('error de conexion')";
  14:         exit();
  15:         }
  16:     if(!(mysql_select_db($basededatos,$enlace)))
  17:         {
  18:         echo " alert('error al conectar con la base de datos')";
  19:         exit();
  20:         }
  21:     return $enlace;
  22:     }
  23:     
  24: function desconectar()
  25:     {
  26:     mysql_close($enlace);
  27:     }
  28: ?>

Ya en el momento de invocarla seria

   1: <?php
   2:  
   3: include "conexionmysql.php";
   4:  
   5: //ESTOS DATOS LOS PUEDES TENER EN OTRO ARCHIVO PHP TE AHORRARIA TIEMPO
   6: $direccion="mysql12.000webhost.com";
   7: $usuario="a5270459_tec";
   8: $pass="Tec101290";
   9: $bd="a5270459_tec";
  10:  
  11: conectar_mysql("$direccion","$usuario","$pass","$bd");
  12:  
  13: ?>

O también lo puedes hacer directamente sin variables

   1: <?php
   2:  
   3: include "conexionmysql.php";
   4:  
   5:  
   6: conectar_mysql("localhost","tuUsuraio","tuPassword","TuBaseDeDatos");
   7:  
   8: ?>

A si este ultimo no les sale traten sin las comillas x) no recuerdo en este momento si llevan x)

Campo de texto vacio

php-logo 
Un pequeño script que verifica si un campo de texto esta vacio

   1: <?PHP
   2: /*FUNCION QUE TE PERMITIRA VALIDAR SI UN CAMPO TE TEXTO ESTA VACIO
   3: Esta función se puede usar en un condición "if" */
   4:  
   5:  function validar_campo($campo)
   6:     {
   7:     if($campo=="")
   8:         return(true);
   9:         echo " alert('El campo de texto esta vacio')";
  10:     else
  11:         return(false);
  12:     }
  13:  ?>

Validación de correo en PHP

php-logo
Una función que sirve para validar si un correo electrónico tiene el formato correcto, es decir, nombre@dominio

Validaciones.php

   1: <?PHP
   2: //FUNCION QUE TE PERMITIRA VALIDAR SI UN CORREO ELECTRICO CON SU FORMATO DE CORREO@SERVIDOR.EXTENCION
   3: function validar_correo($correo)
   4:     {
   5:     if (!strchr($correo,"@") || !strchr($correo,"."))
   6:         {
   7:         echo " alert('Correo electronico no valido')";
   8:         return(false);
   9:         }
  10:     else
  11:         {
  12:         return(true);
  13:         }
  14:     }
  15: ?>

MANEJO DE ARCHIVOS EN 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: }

FRACCIONES EN JAVA

Java-Runtime-Environment-logo
Les dejo un apunte donde manejamos fracciones

   1: package unidad3;
   2:  
   3: import javax.swing.JOptionPane;
   4:  
   5: public class Fraccion 
   6: {
   7: private int num;
   8: private int den;
   9:  
  10: Fraccion()
  11:     {
  12:     num=0;
  13:     den=1;
  14:     }
  15:  
  16: public Fraccion(int num, int den) 
  17:     {
  18:     super();
  19:     this.num = num;
  20:     this.den = den;
  21:     }
  22:  
  23: /** No la uses no funciona a veces el programa se cicla con esta funcion */
  24: public void divisores()
  25:     {
  26:     int numeroPrimo=2;
  27:     int numero=den;
  28:     while(numero!=1)
  29:         {
  30:         if(numero%numeroPrimo==0)
  31:             {
  32:             numero=numero/numeroPrimo;
  33:             System.out.println("divicion entre numero primo es "+numeroPrimo);
  34:             }
  35:         numeroPrimo++;
  36:         
  37:         }
  38:     
  39:     }
  40: /*Maximo común divisor. Busca el numero de mayor valor que pueda dividir al numerador y denominador de la fraccion con la condicion de que no deje residuo */
  41: public int mcd()
  42:     {
  43:     int a=num;
  44:     int b=den;
  45:     int n=1;
  46:     int z=1;;
  47:     if(a>b)
  48:         {
  49:         while(z<=b)
  50:             {
  51:             if(a%z==0 && b%z==0)
  52:                 {
  53:                 n=z;
  54:                 }
  55:             z++;
  56:             }
  57:         }
  58:     if(a<b)
  59:         {
  60:         while(z<=a)
  61:             {
  62:             if(a%z==0 && b%z==0)
  63:                 {
  64:                 n=z;
  65:                 }
  66:             z++;
  67:             }
  68:         }
  69:     return n;
  70:     }
  71: /**Simplifica la fraccion a numeros mas pequeños pero equivalentes */ 
  72: public void simplificar()
  73:     {
  74:     int ns=num/mcd();
  75:     int ds=den/mcd();
  76:     System.out.println(ns+"/"+ds);
  77:     }
  78: /**Suma la fraccion objeto con otra fraccion para guardarla en otra fraccion */
  79: public Fraccion sumar(Fraccion a)
  80:     {
  81:     Fraccion s=new Fraccion((num*a.den)+(den*a.num),den*a.den);
  82:     return s;
  83:     }
  84: /**Multiplica la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */
  85: public Fraccion multiplicar(Fraccion a)
  86:     {
  87:     Fraccion m=new Fraccion(num*a.num,den*a.den);
  88:     return m;
  89:     }
  90: /**Divide la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */
  91: public Fraccion divicion(Fraccion a)
  92:     {
  93:     Fraccion d=new Fraccion(num*a.den,den*a.num);
  94:     return d;
  95:     }
  96: /**Muestra la fraccion completa */
  97: public void mostrarFraccion()
  98:     {
  99:     System.out.println(num+"/"+den);
 100:     }
 101:  
 102: public String toString()
 103: {
 104:     return num+"/"+den;
 105: }
 106:  
 107: }

POTENCIA MATEMATICA EN JAVA

Java-Runtime-Environment-logo
Que tal compañeros  les dejo un apunte, es una función para sacar la potencia, aquí
se manejan excepciones.

   1: package unidad5;
   2:  
   3: public class Potencia {
   4:     
   5:     public static long potencia(long numero, long exponente)
   6:         {
   7:         long resultado=1;
   8:         if(exponente<0)    throw new IllegalArgumentException("Exponente incorrecto");
   9:         for(int x=0; x<exponente; x++)
  10:             {
  11:             resultado=resultado*numero;
  12:             }
  13:         return resultado;
  14:         }
  15:     public static void main(String[] args){
  16:         try{
  17:             System.out.println(potencia(3,3));
  18:         }catch(IllegalArgumentException e){
  19:             System.out.println("");
  20:         }catch(IllegalArgumentException e){
  21:             System.out.println("Exponente incorrecto");
  22:         }
  23:     }
  24:  
  25: }

FACTORIAL EN JAVA

Java-Runtime-Environment-logo
Bueno compañeros les dejo una función hecha en en JAVA que da como resultado el factorial espero y le sirva

   1: package utilerias;
   2:  
   3: public class Mate 
   4: {
   5: public static int factorial(int x)
   6:     {
   7:     int y;
   8:     int f=1;
   9:     for(y=1; y<=x; y++)
  10:         {
  11:         f=f*y;
  12:         }
  13:     return f;
  14:     }
  15: }

Al usarse

   1: package utilerias;
   2:  
   3: public class Prueba {
   4:  
   5:     public static void main(String[] args) 
   6:     {
   7:     System.out.println(Mate.factorial(5));
   8:     }
   9:  
  10: }
Etiquetas de Technorati: ,,

Microsoft Visual Studio Express 2012 para windows 8

Microsoft Visual Studio Express 2012 RC para Windows 8 proporciona las herramientas básicas necesarias para crear aplicaciones estilo Metro de Windows innovadoras y atractivas.

PAGINA DE DESCARGA

Introducción

Puede usar las herramientas de Visual Studio Express 2012 RC para Windows 8 para crear aplicaciones estilo Metro de Windows innovadoras y atractivas. Las herramientas incluyen un completo editor de código, un eficaz depurador, un generador de perfiles especializado y extensa compatibilidad con lenguajes de programación que le permiten compilar aplicaciones escritas en HTML5/JavaScript, C++, C# o Visual Basic. Visual Studio Express 2012 RC para Windows 8 incluye también un simulador de dispositivos para probar las aplicaciones estilo Metro en varios factores de forma.

Requisitos del sistema

Sistemas operativos admitidos:

  • Windows 8 Release Preview Windows 8 Release Preview

  

•Arquitecturas compatibles:

  •  32 bits (x86)
  •  64 bits (x64)

Requisitos de hardware:

  • Procesador a 1,6 GHz o más rápido
  • 1 GB de RAM (1,5 GB si se ejecuta en una máquina virtual)
  • 4.0 GB de espacio disponible en el disco duro
  • Unidad de disco duro de 5400 rpm
  • Tarjeta de vídeo compatible con DirectX 9 con una resolución de pantalla de 1024 x 768 o superior

Página 131 de 141

Creado con WordPress & Tema de Anders Norén