Cesar Systems

Herramientas Informaticas

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: }

Arboles binarios en C++

por

en junio 29, 2012

en Arboles, Arboles binarios, Arboles binarios en C++, C#

Les dejo un viejo apunte de la universidad
Para descargar de clic en descargar
DESCARGAR
 
ARBOLES.CPP
 
   1: #include 

   2: #include 

   3: #include 

   4: #include 

   5:  

   6: typedef int tipodatoarbol;

   7: typedef struct nodo {

   8:    tipodatoarbol dato;

   9:    struct nodo *izq;

  10:     struct nodo *der;

  11: } tipoNodo;

  12: typedef tipoNodo *pNodo;

  13:  

  14: void insertar(pNodo *l,tipodatoarbol Dato);

  15: void inicializar(pNodo *l);

  16: void eliminar(pNodo *l, tipodatoarbol d);

  17: void preorden(pNodo *l);

  18: void inorden(pNodo *l);

  19: void postorden(pNodo *l);

  20:  void menu(pNodo *l);

  21: void inicio(pNodo *l);

  22: void agregar(pNodo *l);

  23: void quitar(pNodo *l);

  24:  

  25: void main()

  26: {

  27:   pNodo arbol;

  28:   menu(&arbol);

  29: }

  30:  

  31: void menu(pNodo *l)

  32: {  int op;

  33:    clrscr();

  34:    gotoxy(33,7);cout<<"ARBOL BINARIO";

  35:    gotoxy(32,9);cout<<"1) Inicializar";

  36:    gotoxy(32,11);cout<<"2) Insertar";

  37:    gotoxy(32,13);cout<<"3) Eliminar";

  38:    gotoxy(32,15);cout<<"4) Imprimir";

  39:    gotoxy(32,17);cout<<"5) Salir";

  40:    do{

  41:      gotoxy(33,19);cout<<"Opcion [ ] ";

  42:      gotoxy(41,19);cin>>op;

  43:    }while (op>5 || op<1);

  44:  

  45:    switch(op)

  46:    {

  47:      case 1:

  48:       inicio(l);

  49:       break;

  50:      case 2:

  51:       agregar(l);

  52:       break;

  53:      case 3:

  54:       quitar(l);

  55:       break;

  56:      case 4:

  57:       clrscr();

  58:       gotoxy(10,16);cout<<" Inorden: ";inorden(l);

  59:       gotoxy(10,17);cout<<" Preorden: ";preorden(l);

  60:       gotoxy(10,18);cout<<" Postorden: ";postorden(l);

  61:       getch();

  62:       menu(l);

  63:       break;

  64:      case 5:

  65:       exit(0);

  66:    }

  67:    getch();

  68: }

  69:  

  70: void inicio(pNodo *l)

  71: { clrscr();

  72:   inicializar(l);

  73:   menu(l);

  74: }

  75:  

  76: void agregar(pNodo *l)

  77: { clrscr();

  78:   int D;

  79:   //char opc='s';

  80:   gotoxy(30,20);cout<<"Insertar numero: "; cin>>D;

  81:     insertar(l,D);

  82:    // cout<>opc;

  83:  // }while(opc=='s' ||opc=='S');

  84:   menu(l);

  85: }

  86: void quitar(pNodo *l)

  87: { clrscr();

  88:   int D;

  89:   //char opc='s';

  90:   //do{

  91:     gotoxy(30,20);cout<<"Numero a eliminar: "; cin>>D;

  92:     eliminar(l,D);

  93:     //gotoxy(12,8);cprintf("nDesea Eliminar otro dato (S/N): "); cin>>opc;

  94:   //}while(opc=='s' ||opc=='S');

  95:   menu(l);

  96: }

  97:  

  98: // FUNCIONES BASICAS

  99: void inicializar(pNodo *l)

 100: {

 101:  *l=NULL;

 102: }

 103:  

 104: //insertar

 105: void insertar(pNodo *l,tipodatoarbol Dato){

 106:     pNodo Nuevo, Aux;

 107:     int b;

 108:     Nuevo=(pNodo)malloc(sizeof(tipoNodo));

 109:     Nuevo->dato= Dato;

 110:     Nuevo->der=NULL;

 111:     Nuevo->izq=NULL;

 112:     Aux=*l;

 113:      if (*l==NULL){

 114:      *l=Nuevo;

 115:     }

 116:     else if (*l!=NULL)

 117:     {

 118:      b=0;

 119:      while(b==0)

 120:     {

 121:     if(Nuevo->datodato)

 122:      {

 123:      while(Aux->izq!=NULL&&Nuevo->datodato)

 124:         { Aux=Aux->izq;}

 125:        if(Nuevo->datodato&&Aux->izq==NULL)

 126:         {Aux->izq=Nuevo;

 127:         b=1;

 128:         }

 129:       else {if(Nuevo->dato>Aux->dato&&Aux->der==NULL)

 130:       {Aux->der=Nuevo;

 131:       b=1;

 132:         } }

 133:      }

 134:      else

 135:        if(Nuevo->dato>Aux->dato)

 136:      {

 137:  

 138:      while(Aux->der!=NULL&&Nuevo->dato>Aux->dato)

 139:         { Aux=Aux->der;}

 140:        if(Nuevo->datodato&&Aux->izq==NULL)

 141:         {Aux->izq=Nuevo;

 142:         b=1;

 143:         }

 144:       else if(Nuevo->dato>Aux->dato&&Aux->der==NULL)

 145:       {Aux->der=Nuevo;

 146:       b=1;

 147:          }

 148:      } }

 149:       }

 150:  

 151: }

 152:  

 153: void eliminar(pNodo *l,tipodatoarbol d)

 154: {

 155:  if(*l==NULL)

 156:  {

 157:   gotoxy(30,20);cout<<"Arbol vacio";

 158:   getch();

 159:  }

 160:  else

 161:  {

 162:   pNodo aux,ant;

 163:   aux=*l;

 164:    while(aux->dato!=d&&(aux->izq!=NULL||aux->der!=NULL))

 165:    {

 166:    if(ddato)

 167:    {

 168:     ant=aux;

 169:     aux=aux->izq;

 170:    }

 171:    else

 172:    {

 173:     ant=aux;

 174:     aux=aux->der;

 175:    }

 176:   }

 177:   if(aux->dato==d)

 178:   {

 179:    if(aux==*l&&aux->izq==NULL&&aux->der==NULL)

 180:    {

 181:     inicializar(l);

 182:    }

 183:    else

 184:    {

 185:     if(aux->izq!=NULL&&aux->der!=NULL)

 186:     {

 187:      ant=aux;

 188:      aux=aux->izq;

 189:      if(aux->der==NULL)

 190:      {

 191:       ant->dato=aux->dato;

 192:       ant->izq=aux->izq;

 193:      }

 194:      else

 195:      {

 196:       pNodo ant2;

 197:       while(aux->der!=NULL)

 198:       {

 199:        ant2=aux;

 200:        aux=aux->der;

 201:       }

 202:       ant->dato=aux->dato;

 203:       if(aux->izq==NULL)

 204:       {

 205:        ant2->der=NULL;

 206:       }

 207:       else

 208:       {

 209:        ant2->der=aux->izq;

 210:       }

 211:      }

 212:     free(aux);

 213:    }

 214:    else

 215:     if(aux->izq!=NULL||aux->der!=NULL)

 216:     {

 217:      if(aux->izq!=NULL)

 218:      {

 219:       if(aux->datodato)

 220:       {

 221:        if(aux==*l)

 222:     *l=aux->izq;

 223:        else

 224:     ant->izq=aux->izq;

 225:       }

 226:       else

 227:       {

 228:        if(aux==*l)

 229:     *l=aux->izq;

 230:        else

 231:        ant->der=aux->izq;

 232:       }

 233:      }

 234:      else

 235:      {

 236:       if(aux->datodato)

 237:       {

 238:        if(aux==*l)

 239:     *l=aux->der;

 240:        else

 241:     ant->izq=aux->der;

 242:       }

 243:       else

 244:       {

 245:        if(aux==*l)

 246:     *l=aux->der;

 247:        else

 248:     ant->der=aux->der;

 249:       }

 250:      }

 251:      free(aux);

 252:     }

 253:     else

 254:      if(aux->izq==NULL&&aux->der==NULL)

 255:      {

 256:       if (aux->datodato)

 257:        ant->izq=NULL;

 258:       else

 259:        ant->der=NULL;

 260:       free(aux);

 261:      }

 262:     }

 263:    }

 264:    else

 265:    {

 266:     gotoxy(30,20);cout<<"Numero no existente";

 267:     getch();

 268:    }

 269:  }

 270: }

 271: void preorden(pNodo *l){

 272:   pNodo Aux,*l2;

 273:   Aux=*l;

 274:   if(*l!=NULL){

 275:     cout<<" "<dato;

 276:     *l2=Aux->izq;

 277:     preorden(l2);

 278:     *l2=Aux->der;

 279:     preorden(l2);

 280:   }

 281: }

 282:  

 283:  

 284: void inorden(pNodo *l){

 285:   pNodo Aux,*l2;

 286:   Aux=*l;

 287:   if(*l!=NULL){

 288:     *l2=Aux->izq;

 289:     inorden(l2);

 290:     cout<<" "<dato;

 291:     *l2=Aux->der;

 292:     inorden(l2);

 293:   }

 294: }

 295:  

 296: void postorden(pNodo *l){

 297:   pNodo Aux,*l2;

 298:   Aux=*l;

 299:   if(*l!=NULL){

 300:     *l2=Aux->izq;

 301:     postorden(l2);

 302:     *l2=Aux->der;

 303:     postorden(l2);

 304:     cout<<" "<dato;

 305:   }

 306: }

 307: 

Cadena de Markov – Investigación de operaciones 2

por

en junio 29, 2012

en cadena de markov, investigacion de operaciones 2

INSTITUTO TECNOLÓGICO

DE LOS MOCHIS

LIC. INFORMATICA

ALUMNOS:

MIJAIL HERRERA FIGUEROA

JULIO CESAR LEYVA RODRIGUEZ

MATERIA:

INVESTIGACION DE OPERACIONES II

DOCENTE:

CHARLY HERVEY

LOS MOCHIS SINALOA 2010
CADENA DE MARKOV
En una empresa de sexoservidoras se tienen establecidos 3 tipos de servicios: Premium, regular y normal de 3 dichas servidoras, para la servidora 1 el 10% es regular y el 8% es normal lo que para la servidora 2 el 17% es regular y el 10% es normal y lo que para la servidora 3 el 33% es normal y el 3% es regular.

  • Realizar la matriz de transición
  • Elaborar la cadena de Markov
  • Sacar la probabilidad para 2,4 y 8 días.

MATRIZ DE TRANSICION

             Premium regular Normal

Premium 0.82       0.10     0.08

Regular 0.73       0.17      0.10

Normal 0.60       0.07       0.33

                                                 CADENA DE MARKOV

 

                                                     PARA 2 DIAS

             Premium  regular Normal

Premium 0.7934 0.1046 0.102

Regular 0.7827 0.1089 0.1084

Normal 0.7411 0.095 0.1639

PARA 4 DIAS

Premium regular Normal

Premium 0.78694618 0.10407058 0.10898324

Regular 0.78656545 0.10402763 0.10940692

Normal 0.78381153 0.10343506 0.11275341

PARA 8 DIAS

                Premium              regular             Normal

Premium  0.786564932   0.103996849   0.109438218

Regular 0.78656321       0.103996581    0.109439797

Normal 0.772848898     0.10399448     0.109452162

PROGRAMACION DINAMICA

Se construyo especialmente para ilustrar la ruta y las características e introducir la termino logia de la programación dinámica. Este paradigma se refiere a la ruta que hay actualmente desde los Mochis Sinaloa hasta ensenada baja california norte en una agencia de autotransportes.

A. LOS MOCHIS, SINALOA

B. NAVOJOA, SONORA

C. OBREGON, SONORA

D. GUAYMAS,SONORA

E. SANTANA, SONORA

F. HERMOSILLO, SONORA

G. MEXICALI, BAJA CALIFORNIA NORTE

H. TIJUANA, BAJA CALIFORNIA NORTE

I. TECATE, BAJA CALIFORNIA NORTE

J. ENSENADA, BAJA CALIFORNIA NORTE

 



Drivers Controladores autoinstalables HP Mini 210-3000 Windows 7

por

en junio 27, 2012

en Atheros AR9285 802.11b/g/n WiFi Adapter, Controladores, Drivers, Intel 82801GBM ICH7-M - Audio Controller, Intel(R) Graphics Media Accelerator 3150, Realtek PCIe FE Family Controller

Drivers autoinstalables HP Mini 210-3000

Contenido del paquete

Intel 82801GBM ICH7-M – High Definition Audio Controller
Atheros AR9285 802.11b/g/n WiFi Adapter
Realtek PCIe FE Family Controller
Intel(R) Graphics Media Accelerator 3150

 

Drivers controladores Windows XP

por

en junio 27, 2012

en ATI Redeon X1200 Series, Controladores, Drivers, Drivers autoinstalables, Realtek Hight Definition Audio, Realtek RTL8139/810x Family Fast Ethernet NIC

Les dejo un paquete de drivers autoinstalable, es facil, solo selecciona el drivers que quieras instalar y listo.

Funciona solo para Windows XP

 

Estos driver son de una computadora armada a continuación le mostrare que drivers contiene el paquete

ATI IDE Controller

ATI Redeon X1200 Series

ATI SMBus

Realtek Hight Definition Audio

Realtek RTL8139/810x Family Fast Ethernet NIC

DESCARGAR

Quitar mensaje de advertencia en php

por

en junio 6, 2012

en error reporting, php

Nomas te  vas a la pagina principal del php y pones la siguiente linea

error_reporting (5); 

Ensayo taller de aplicaciones para los negociosr de aplicaciones para los negocios

por

en mayo 25, 2012

en ensayo, Taller de aplicaciones para los negocios

Instituto Tecnológico de Los Mochis

Departamento de Sistemas y Computación

Licenciatura en Informática

Materia:

Taller de aplicaciones para los negocios

Ensayo de: Aspectos legales del comercio electrónico

Leyva Rodríguez Julio Cesar

                                                                                                               

Los Mochis Sinaloa Mayo del 2012

INTRODUCCIÓN

Actualmente los desarrolladores de software en el instituto tecnológico de Los Mochis han estado diseñando, programando y creando contenido para crear un sistema web que  permita el comercio electrónico a las empresas que se dedican a la compra-venta de productos o servicios, sin embargo, muchos de ellos desconocen la importancia de tomar en cuenta los aspectos legales.

Cuando a un estudiante de informática se le mencionan los aspectos legales en el desarrollo de sitios donde se lleva a cabo el comercio electrónico, muchos de ellos toman una postura de precaución al creer que se les va a buscar por usar contenido protegido.

Aunque es importante conocer la legislación y aspectos legales del comercio electrónico para evitar demandas y reclamos por usar contenido protegido, se debe decir que es de importancia que el alumno sepa la legislación y los aspectos legales para que en un momento dado que tenga sus propios contenidos y diseños ejecute el procedimiento adecuado para proteger el contenido de su sistema y no sea registrado por alguna persona ajena al proyecto.

Es de vital importancia proteger lo que es nuestro sea código fuente, contenido, diseño por que si otra persona legalmente lo registra podría quedar como el dueño legal de la propiedad intelectual, esto ha pasado con registro de los nombres de dominio. 

ENSAYO

El flujo de la información que existe en el internet jamás se detiene, las 24 horas del día minuto a minuto una persona esta escribiendo programas diseñando plantillas web y publicando contenido de interés para atraer visitantes al sitio web.[5]

En muchos de los casos se copea información, diseño para atraer más visitas a nuestro sitio web, lo cual se protege con la propiedad intelectual. [5]

En el desarrollo de un sitio web se deben proteger 3 aspectos

·         La información que se maneja

·         El diseño grafico

·         El código fuente

En mi opinión la información debe protegerse más si se trata de una página donde se maneje comercio electrónico, ya que en el sistema se pueden encontrar datos de los usuarios, o de proveedores de los productos que se manejen en el sistema. [5]

También pienso que el arte del sistema web debe ser protegido y evitar ser copiado por varias razones por ejemplo:

·         Competencia que por medio del uso de imágenes de productos, logotipos, eslogan el cliente puede confundir el sitio con el original, aquí se pueden ejecutar acciones legales.

·         El arte del sitio que el diseño de la plantilla, imágenes, iconos, fotografías, animaciones, dibujos todos estos requieren de esfuerzo mental e inspiración para realizarse y como para que otro lo copie así nomas no es justo.[5]

Por ultimo el código fuente, como HTML se ejecuta sin ser compilado es muy fácil de ser copiado, ya dependería el nivel de complejidad de la programación, ya que en el lenguaje HTML puede existir código común, pero si estoy de acuerdo de que se deba proteger el código fuente mas aun por el código que se ha de ejecutar en el servidor que seria PHP o ASP. [5]

En lo que se refiere a la protección de datos de carácter personal, veo que es importante para nosotros como desarrolladores de sitios que van a tener datos de los clientes o de  los usuarios tomar en cuenta la protección de sus datos personales, ya que en esto se juega la reputación de toda la empresa que esta ligada con el sistema, además si no se toman medidas para proteger la información de los clientes o usuarios tendríamos problemas legales ya que la legislación nacional los protege. [1]

En el desarrollo de un sistema web donde se maneje el comercio electrónico es de vital importancia tomar en cuenta analizar la diferencia entre tener un dominio que te otorga un proveedor de servicios de internet a tener todos los derechos sobre el. [10]

A pasado muchas veces que las empresas solo tienen el nombre del dominio que les asigno la institución encargada de la administración de dominios, pero no realizaron los tramites necesarios para tener derecho sobre ellos, lo que paso fue que alguien ajeno a la empresa(s) tomo para si los derechos, muchas veces tratan de ceder los derechos a un precio muy elevado. [10]

Para detener este abuso tenemos a nuestro favor a OMPI que sus siglas significan Organización Mundial de la Propiedad Intelectual, esta organización es la que resuelve los conflictos entre particulares que exigen los derechos de un mismo dominio, y en caso de que alguien resulte culpable se tomaran acciones judiciales contra el usurpador.[2]

La conferencia de Plenipotenciarios de la unión internacional de comunicaciones (Marrakech, 2002)  refiriéndose a la gestión de nombres de dominio y direcciones de internet tiene como objetivo promover el ámbito internacional la adopción de un enfoque amplio de las cuestiones de las telecomunicaciones en la economía y la sociedad de la información mundial, promover la extensión de los beneficios de nuevas tecnologías de comunicaciones a todos los habitantes del planeta y armonizar los esfuerzos de los estados miembros y miembros de todos los sectores para que todo esto pueda ser realizado.[6]

En mi opinión esto deberá llegar a los habitantes de todo el mundo sin discriminación por sexo, raza, religión o lugar de residencia. [6]

Desde mi punto de vista teniendo una vaga idea hacia el futuro relacionar lo anterior con el comercio electrónico, cualquier empresa podrá vender desde cualquier parte del mundo a cualquier parte del mundo, pero que ha de pasar con las pequeñas y medianas empresas, ¿habrá un monopolio global?, todo esto tendrá que ser bien regulado para que las pequeñas y medianas empresas locales no desaparezcan. [6]

Falta ver la otra parte oscura del comercio electrónico, que son los delitos informáticos, los días en los que los asaltantes entraban a las tiendas comerciales y a punta de pistola es casi tan anticuado como los asaltantes que a caballo tomaban los trenes en el viejo oeste, los melandros pioneros de hoy tienen usan el dicho “mas vale maña que fuerza”, es decir, usan la inteligencia para aprovecharse de las vulnerabilidades de los sistemas de comercio electrónico, los delitos que mas se realizan a nivel mundial son:

·         Estafas

·         Fraudes

·         Sustracción de datos confidenciales

·         Falsificaciones informáticas

·         Robo de identidad

·         Robo de servicios [4]

Como desarrolladores de sistemas nosotros debemos tomar todas las medidas posibles para evitar cualquier tipo de delitos, no nomas en la programación ya que en la mayoría de los casos los fraudes vienen desde el personal corrupto dentro de la empresa, también por errores y descuidos de los usuarios, por lo cual se deben de realizar auditorias al personal que tenga acceso relevante al sistema y postular normas de uso para los  clientes y usuarios en general. [4]

Los mismo para la contratación electrónica, también se deben tomar medidas para evitar para que nadie que no deba ser firme un contrato. La contratación  electrónica también nos servirá en el registro de clientes y usuarios cuando acepte los términos y condiciones de uso del sistema web. [7]

Para la legislación de la contratación electrónica o contratación telemática existe el Real Decreto 1906/1999, de 17 de diciembre, por el que se regula la contratación telefónica o electrónica con condiciones generales. En lo personal se deberían copiar algunas de estas leyes para la contratación telemática tanto en México como toda América Latina. En los artículos de este decreto se mencionan las normas que rigen el proceso de la contratación electrónica o telemática. [9]

Para los comerciantes minoristas en territorio español nos podemos valer de la Ley 7/1996, de 15 de enero, de Ordenación del comercio minorista aquí no se aplica los derechos de autor o las obligaciones contractuales de los contratos de los consumidores [8]

Al leer la directica 2000/31/CE, de 8 de junio, del parlamento Europeo y del consejo, relativa a los determinados aspectos jurídicos de la sociedad de la información, en lo particular el comercio electrónico en el mercado interior. Es interesante que aunque esta ley fue decretada para la Unión Europea se propone también evitar  incompatibilidades con la evolución jurídica de otras regiones del mundo esto para no obstaculizar el comercio electrónico mundial. [3]

CONCLUSIÒN

Es de vital importancia tener los derechos intelectuales de nuestro sitio para evitar que la competencia pueda copiar e imitar nuestros diseños y contenidos ya que si lo hacen los clientes confundirán los sitios demeritando nuestro prestigio.

También es necesario obtener los derechos de nuestro dominio aun antes de que el sistema de comercio electrónico este en funcionamiento, esto evitara que un extraño lo reclame antes que nosotros.

En caso de que algún extraño tome los derechos de nuestro dominio se podrá hacer el intento de recurarlo por medio de OMPI “Organización Mundial de la Propiedad Intelectual.

Es necesario también que nuestros clientes o usuarios sientan la seguridad de que sus datos personales estén seguros, por lo cual, se deben tomar medidas de seguridad en el personal de la empresa y normas y manuales del uso optimo del sistema para los usuarios.

Y por ultimo es necesario mencionar las leyes que se han estado decretando en la Unión Europea ya que es posible que se extienda a nivel mundial.

   

REFERENCIAS

[1] html.rincondelvago.com, Protección de datos de carácter personal, 06/05/12, http://html.rincondelvago.com/proteccion-de-datos-caracter-personal-en-la-jurisprudencia-contencioso-administrativa.html

[2] iabogado.com, La OMPI y los nombres de dominio, 06/05/12, http://iabogado.com/guia-legal/nuevas-tecnologias/nombres-de-dominio/lang/es#18020400000000

[3] www.europa.eu, Directiva 2000/31/CE, de 8 de junio, 06/05/12, http://europa.eu/legislation_summaries/information_society/other_policies/l24204_es.htm

[4] www.informatica-juridica.com, Los llamados “Delitos informáticos”, 06/05/12, http://www.informatica-juridica.com/trabajos/rasgos_afines.asp

[5] www.institutoblestgana.com, Propiedad intelectual, 06/05/12,  http://www.institutoblestgana.cl/virtuales/comercio_electronico/Unidad3/contenido6.htm

[6] www.itu.int, Gestión de los nombre de dominio, 06/05/12, http://www.itu.int/aboutitu/basic-texts/resolutions/res102-es.html

[7] www.juridicas.com, Contratación electrónica, 06/05/12,  http://noticias.juridicas.com/articulos/20-Derecho%20Informatico/200806-84597852231456.html

[8] www.juridicas.com, Ley 7/1996, de 15 de enero, de Ordenación del Comercio Minorista, 06/05/12, http://noticias.juridicas.com/base_datos/Privado/l7-1996.t1.html#a1

[9] www.juridicas.com, Real Decreto 1906/1999, de 17 de diciembre, por el que se regula la contratación telefónica o electrónica con condiciones generales, 06/05/12, http://noticias.juridicas.com/base_datos/Admin/rd1906-1999.html

[10] www.legalsismarcas.com, Derechos sobre marcas y derechos sobre dominios de internet, 06/05/12,  http://www.legalsismarcas.com/blog-marcas/dominios-internet-derechos-marca/

Joomla uddeimpms CB

por

en mayo 24, 2012

en Sin categoría

Warning: require_once(/home/a8071320/public_html/components/com_uddeim/uddeimlib17.php) [function.require-once]: failed to open stream: No such file or directory in /home/a8071320/public_html/components/com_comprofiler/plugin/user/plug_privatemessagingsystem(uddeimpms)/pms.uddeim.php on line 20


Fatal error: require_once() [function.require]: Failed opening required ‘/home/a8071320/public_html/components/com_uddeim/uddeimlib17.php’ (include_path=’.:/usr/lib/php:/usr/local/lib/php’) in/home/a8071320/public_html/components/com_comprofiler/plugin/user/plug_privatemessagingsystem(uddeimpms)/pms.uddeim.php on line 20




Solucion
Ir al gestor de plugins de Community Builder y desistanlar todo lo que diga uddeIM
Son 4 plugins

Publicidad subliminal

por

en abril 21, 2012

en mensajes subliminales, Publicidad subliminal

Un ejemplo de publicidad subliminal son las latas de pepsicola, en las que se puede leer “SEX o SEXI”

Técnicas para el acopio de información

por

en abril 21, 2012

en evaluacion de proyectos, HOJA DE PRESENTACION DE LA UAS UNIVERSIDAD AUTONOMA DE SINALOA PORTADA PORTADAS LOS MOCHIS, ITLM, Técnicas para el acopio de información

Las técnicas de acopio de información se refiere a la busqueda de información en el mercado en donde nosotros vamos a lanzar nuestro producto, estas tecnicas incluyen: cuestionarios, encuestas, llamadas telefonicas, entrevistas, etc.

 

Dentro de un proceso de investigación una de las actividades que se realizan es la recopilación de datos, la cual es el acopio de información y se incluye desde elaborar fichas bibliográficas hasta la aplicación de cuestionarios con el empleo de técnicas de muestreo.

 

Existe una gran variedad de técnicas para realizar la investigación, que se deberán seleccionar de acuerdo a las necesidades del problema, así como a diferentes factores como son el tiempo, costo, tipo de actividades a realizar, recursos humanos, etc.

 

 

 

Las técnicas de recopilación de datos las podemos realizar con:

  • Investigación documental
  • Investigación de campo

LA INVESTIGACIÓN DOCUMENTAL. Consiste en el estudio de documentos escritos sobre un objeto determinado, es decir son todos aquellos documentos registrados en diferentes dispositivos físicos a los que podemos tener acceso en forma directa o indirecta para su consulta y se puede clasificar en:

  1. Documental bibliográfica
  2. Documental hemerográfica
  3. Documental escrita
  4. Documental audiográfica
  5. Documental videográfica
  6. Documental iconográfica
 LA ENTREVISTA. Es una de las técnicas más comunes y es considerada como la relación directa entre el investigador y el objeto de estudio a través de individuos o grupos con el fin de obtener testimonios reales. se pueden realizar como:

a) Entrevistas formales

b) Entrevistas informales

LA ENCUESTA. Consiste en recopilar información sobre una parte e la población, en donde la información recopilada puede emplearse para un análisis cuantitativo con el fin de identificar las magnitudes del problema. Para realizarla es posible con:

a) Un cuestionario

b) Una cedula de entrevista

EL CUESTIONARIO. Es un eficaz auxiliar en la observación científica que contiene aspectos del fenómeno esenciales, las cuales son preguntas formuladas por escrito y no es necesario la presencia del investigador llevándose a cabo mediante:

– Cuestionarios por correo

– Cuestionario administrado por el entrevistado

Cuestionario administrado por el entrevistador

LA CEDULA. Tiene carácter de anónimo, donde el encuestador es quien llena la cedula de entrevista, además de que es posible aclara la información sobre las preguntas y es utilizada cuando una persona tiene un bajo nivel cultural.

 

Página 135 de 143

Anterior

Siguiente

Creado con WordPress & Tema de Anders Norén