elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Problema guardando 2d arrays en binarios
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Problema guardando 2d arrays en binarios  (Leído 2,030 veces)
julianbesso1

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Problema guardando 2d arrays en binarios
« en: 5 Agosto 2014, 05:08 am »

Hola a todos. Nuevamente con un problema. Me pidieron que realice una sopa de letras que brinde la posibilidad de guardar la partida para retomar en otro momento. Es aquí donde fallo. No estoy muy seguro del código correspondiente a write y read (líneas 203 y 251 respectivamente)

Código
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <conio2.h>
  6. #include <ctime>
  7. #include <stdlib.h>
  8. #include <windows.h>
  9. #include <ctype.h>
  10.  
  11. using namespace std;
  12.  
  13. void imprimir_sopa(char x[20][20]);
  14. void imprimir_indices();
  15. void imprimir_encontradas(int x[5][4], char y[5][21]);
  16. void marcar_palabra(int x[5][4], char y[5][21]);
  17. void victoria(char w[20][20], int x[5][4], char y[5][21]);
  18.  
  19. int main(int argc, char *argv[]) {
  20.  
  21.   int cont=0;  
  22.   char c;
  23.  
  24.   int lista_found=0;
  25.   char lista[5][21];
  26.   bool s;
  27.  
  28.   char sopa[20][20];  //declaración e inicialización los elementos de la sopa con '?'
  29.  
  30.   int sopa_found=0, posx, posy, dir1, registro[5][3];  //contador de palabras encontradas, posiciones X e Y de las iniciales, dir1=hor/ver/diag,  
  31.   bool t;                                      //registro de TODAS las palabras de la lista
  32.  
  33.   char alphabet[27]={"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
  34.  
  35.   int found[5][4];  //declaración e inicialización del registro de las palabras que son encontradas (posx, posy, dir1, strlen)
  36.  
  37.   int d, dir2, palabras_found=0;
  38.   int posx2, posy2;
  39.  
  40.   char g;  
  41.  
  42.   while(g!='3'){
  43.  
  44.      textcolor(LIGHTRED);
  45.      cout<<"BIENVENIDO A LA SOPA DE LETRAS"<<endl<<endl;
  46.      textcolor(WHITE);
  47.      cout<<"Elija una opci\242n"<<endl<<endl;
  48.      cout<<"1) Partida nueva"<<endl;
  49.      cout<<"2) Continuar con la \243ltima partida guardada"<<endl;
  50.      cout<<"3) Salir"<<endl<<endl;
  51.  
  52.      g=getch();
  53.  
  54.      if(g=='1'){        
  55.  
  56.         ifstream entrada("listado de palabras.txt", ios::in);
  57.  
  58.         while (entrada.good()){  //leer cantidad de veces que aparece '\n' en el txt      
  59.            c = entrada.get();
  60.            if (c=='\n')cont++;
  61.         }      
  62.         entrada.close(); //si se accede manualmente al archivo .txt se debe ingresar la última palabra de la lista acompañado de \n.
  63.         //caso contrario el código detectará una palabra de menos
  64.         char** q=new char*[cont];
  65.  
  66.         for(int f=0; f<cont; f++){
  67.            q[f]=new char[21];      
  68.         }
  69.  
  70.         entrada.open("listado de palabras.txt", ios::in);
  71.  
  72.         for(int g=0; g<cont; g++){
  73.            entrada.getline(q[g], 20);
  74.            strupr(q[g]);
  75.         }
  76.  
  77.         entrada.close();        
  78.  
  79.         srand(time(NULL));
  80.  
  81.         while(lista_found<5){  //asignación de las palabras aleatorias (5)
  82.            s=true;
  83.            int a=rand()%cont;
  84.            for(int j=0; j<5; j++){
  85.               if(strcmp(q[a],lista[j])==0){
  86.                  s=false;
  87.                  break;
  88.               }
  89.            }      
  90.            if(s==true){
  91.               strcpy(lista[lista_found],q[a]);
  92.               lista_found++;
  93.            }
  94.            Sleep(1000);
  95.         }
  96.  
  97.         for(int r=0; r<cont; r++){
  98.            delete[] q[r];  
  99.         }
  100.  
  101.         delete[] q;        
  102.  
  103.         for(int k=0; k<20; k++){
  104.            for(int l=0; l<20; l++){
  105.               sopa[k][l]='?';
  106.            }  
  107.         }        
  108.  
  109.         while(sopa_found<5){  //inserción de palabras
  110.  
  111.            posx=rand()%20;
  112.            posy=rand()%20;
  113.            dir1=rand()%3+1;
  114.  
  115.            if(dir1==1){  //horizontal
  116.               if(posy+strlen(lista[sopa_found])<=20){
  117.                  t=true;
  118.                  for(int m=posy; m<posy+strlen(lista[sopa_found]); m++){
  119.                     if(sopa[posx][m]!='?'){
  120.                        t=false;
  121.                        break;
  122.                     }              
  123.                  }
  124.                  if(t==true){
  125.                     registro[sopa_found][0]=posy+1;
  126.                     registro[sopa_found][1]=posx+1;
  127.                     registro[sopa_found][2]=dir1;
  128.                     for(int n=0; n<strlen(lista[sopa_found]); n++){
  129.                        sopa[posx][posy]=lista[sopa_found][n];
  130.                        posy++;
  131.                     }            
  132.                     sopa_found++;
  133.                  }
  134.               }
  135.            }
  136.            if(dir1==2){  //vertical
  137.               if(posx+strlen(lista[sopa_found])<=20){
  138.                  t=true;
  139.                  for(int o=posx; o<posx+strlen(lista[sopa_found]); o++){
  140.                     if(sopa
  141.  
  142.    [posy]!='?'){
  143.  
  144.                        t=false;
  145.                        break;
  146.                     }              
  147.                  }
  148.                  if(t==true){
  149.                     registro[sopa_found][0]=posy+1;
  150.                     registro[sopa_found][1]=posx+1;
  151.                     registro[sopa_found][2]=dir1;
  152.                     for(int p=0; p<strlen(lista[sopa_found]); p++){
  153.                        sopa[posx][posy]=lista[sopa_found][p];
  154.                        posx++;
  155.                     }
  156.                     sopa_found++;
  157.                  }
  158.               }        
  159.            }
  160.            if(dir1==3){  //diagonal
  161.               if(posx+strlen(lista[sopa_found])<=20&&posy+strlen(lista[sopa_found])<=20){
  162.                  t=true;
  163.                  for(int q=posx, r=posy; q<posx+strlen(lista[sopa_found]); q++, r++){
  164.                     if(sopa[q][r]!='?'){
  165.                        t=false;
  166.                        break;
  167.                     }              
  168.                  }
  169.                  if(t==true){
  170.                     registro[sopa_found][0]=posy+1;
  171.                     registro[sopa_found][1]=posx+1;
  172.                     registro[sopa_found][2]=dir1;
  173.                     for(int s=posx, t=posy, u=0; s<posx+strlen(lista[sopa_found]); s++, t++, u++){
  174.                        sopa[t]=lista[sopa_found];
  175.                     }
  176.                     sopa_found++;
  177.                  }
  178.               }
  179.            }
  180.         }        
  181.  
  182.         for(int v=0; v<20; v++){  //relleno de los elementos restantes
  183.            for(int w=0; w<20; w++){
  184.               if(sopa[v][w]=='?'){
  185.                  int a=rand()%26;
  186.                  sopa[v][w] = alphabet[a];
  187.               }
  188.            }
  189.         }      
  190.  
  191.         for(int x=0; x<5; x++){
  192.            for(int y=0; y<4; y++){
  193.               if(y!=3)found
  194.  
  195.    [y]=100;
  196.  
  197.               else found
  198.  
  199.    [y]=strlen(lista
  200.    );
  201.  
  202.            }
  203.         }
  204.  
  205.      }
  206.  
  207.      if(g=='1'||g=='2'){
  208.  
  209.         fstream arch;
  210.  
  211.         if(g=='2'){
  212.  
  213.            arch.open("sopa saved.dat", ios::binary);
  214.  
  215.            arch.read(sopa[0], 20*20*sizeof(sopa));
  216.  
  217.            arch.read((char *)found[0], 5*4*sizeof(found));
  218.  
  219.            arch.read(lista[0], 5*21*sizeof(lista));
  220.  
  221.            arch.read((char *)palabras_found,sizeof(palabras_found));
  222.  
  223.            arch.close();
  224.  
  225.         }
  226.  
  227.         clrscr();  
  228.  
  229.         while(palabras_found<5){
  230.  
  231.            int w;
  232.  
  233.            clrscr();
  234.  
  235.            textcolor(LIGHTRED);
  236.            gotoxy(6,1);
  237.            cout<<"BIENVENIDO A LA SOPA DE LETRAS"<<endl<<endl;
  238.  
  239.            imprimir_sopa(sopa);
  240.            imprimir_indices();
  241.            imprimir_encontradas(found, lista);
  242.            marcar_palabra(found, lista);
  243.  
  244.            gotoxy(1,26);
  245.            cout<<"Tienes que encontrar las siguientes palabras:"<<endl<<endl;
  246.  
  247.            for(int i=0; i<5; i++){
  248.               cout<<i+1<<" - ";
  249.               puts(lista);
  250.            }
  251.  
  252.            cout<<"\n(Nota: Las dimensiones de la sopa son 20x20)"<<endl<<endl;      
  253.            cout<<"Buscar palabra No.: ";
  254.            textcolor(YELLOW);
  255.            cout<<"(Save
  256.  
  257.    Exit [6]) ";
  258.  
  259.            textcolor(WHITE);
  260.            cin>>d;
  261.  
  262.            if(d==0){
  263.  
  264.               arch.open("sopa saved.dat", ios::binary);
  265.  
  266.               arch.write(sopa[0], 20*20*sizeof(sopa));
  267.  
  268.               arch.write((char *)found[0], 5*4*sizeof(found));
  269.  
  270.               arch.write(lista[0], 5*21*sizeof(lista));
  271.  
  272.               arch.write((char *)palabras_found,sizeof(palabras_found));
  273.  
  274.               arch.close();
  275.  
  276.               gotoxy(1,36);
  277.               textcolor(LIGHTMAGENTA);
  278.               cout<<"(Partida guardada)                       ";
  279.               //textcolor(WHITE);
  280.               Sleep(2000);
  281.               clrscr();      
  282.  
  283.            }  
  284.            if(d!=0){
  285.  
  286.               if(d==6){
  287.                  clrscr();
  288.                  break;
  289.               }
  290.  
  291.               else{
  292.                  cout<<endl;
  293.                  cout<<"Coordenada 'X' de la inicial: ";
  294.                  cin>>posx2;;
  295.                  cout<<"Coordenada 'Y' de la inicial: ";
  296.                  cin>>posy2;
  297.                  cout<<"Horizontal [1] Vertical [2] Diagonal [3] ? ";
  298.                  cin>>dir2;
  299.  
  300.                  w=d-1;      
  301.  
  302.                  if(posx2==registro[w][0]&&posy2==registro[w][1]&&dir2==registro[w][2]){
  303.                     textcolor(LIGHTGREEN);
  304.                     cout<<"\nExcelente! La has adivinado";
  305.                     for(int i=0; i<3; i++){
  306.                        found[w]=registro[w];
  307.                     }
  308.                     Sleep(2000);
  309.                     marcar_palabra(found, lista);
  310.                     palabras_found++;
  311.                     textcolor(WHITE);
  312.                  }
  313.                  else {
  314.                     textcolor(LIGHTRED);
  315.                     cout<<"\nIncorrecto... Intenta otra vez!";
  316.                     Sleep(2000);
  317.                     textcolor(WHITE);
  318.                  }
  319.  
  320.               }
  321.            }
  322.         }
  323.  
  324.         if(palabras_found==4) victoria(sopa, found, lista);            
  325.  
  326.      }      
  327.  
  328.   }
  329.  
  330.   clrscr();
  331.   cout<<"FIN";
  332.  
  333.   return 0;
  334.  
  335.  
  336. }
  337.  
  338. void imprimir_sopa(char x[20][20]){
  339.  
  340.   textcolor(WHITE);
  341.  
  342.   for(int i=0; i<20; i++){
  343.      for(int j=0; j<20; j++){
  344.         cout<<" ";
  345.         cout<<x[j];
  346.         if(j==19) cout<<endl;
  347.      }  
  348.   }
  349. }
  350.  
  351. void imprimir_indices(){
  352.  
  353.   textcolor(YELLOW);
  354.  
  355.   gotoxy(2,24);  //eje X
  356.   for(int i=0; i<20; i++){
  357.      cout<<i+1;
  358.      if(i<9) cout<<" ";
  359.   }
  360.   gotoxy(43,3);  //eje Y (puede omitirse)
  361.   int h=0;
  362.   for(int j=0; j<20; j++){
  363.      gotoxy(43,3+h);
  364.      cout<<j+1;
  365.      cout<<endl;      
  366.      h++;
  367.   }
  368.  
  369.   textcolor(WHITE);
  370.  
  371. }
  372.  
  373. void imprimir_encontradas(int x[5][4], char y[5][21]){
  374.  
  375.   textcolor(LIGHTMAGENTA);
  376.  
  377.   for(int i=0; i<5; i++){
  378.  
  379.      if(x
  380.  
  381.    !=100){
  382.  
  383.  
  384.         gotoxy((x
  385.  
  386.    )*2,x[1]+2);
  387.  
  388.  
  389.         if(x[2]==1){  //horizontal
  390.            for(int t=0; t<x[3]; t++){
  391.               cout<<y[t];
  392.               cout<<" ";
  393.            }      
  394.         }
  395.         if(x[2]==2){  //vertical
  396.            int h=1;
  397.            for(int t=0; t<x[3]; t++){
  398.               cout<<y[t];
  399.               gotoxy((x
  400.  
  401.    )*2,x[1]+2+h);
  402.  
  403.               h++;
  404.            }      
  405.         }
  406.         if(x[2]==3){  //diagonal
  407.            int h=1, k=2;
  408.            for(int t=0; t<x[3]; t++){
  409.               cout<<y[t];
  410.               gotoxy((x
  411.  
  412.    )*2+k,x[1]+2+h);
  413.  
  414.               h++; k+=2;
  415.  
  416.            }      
  417.         }
  418.  
  419.      }
  420.   }
  421.  
  422.   textcolor(WHITE);
  423. }
  424.  
  425. void marcar_palabra(int x[5][4], char y[5][21]){  
  426.  
  427.   textcolor(LIGHTMAGENTA);
  428.  
  429.   for(int i=0; i<5; i++){
  430.      if(x
  431.  
  432.    !=100){
  433.  
  434.         gotoxy(6+x[3],28+i);
  435.         cout<<"X";
  436.      }
  437.   }
  438.  
  439.   textcolor(WHITE);
  440. }
  441.  
  442. void victoria(char w[20][20], int x[5][4], char y[5][21]){
  443.  
  444.   clrscr();
  445.  
  446.   gotoxy(6,1);
  447.   textcolor(LIGHTRED);
  448.   cout<<"BIENVENIDO A LA SOPA DE LETRAS"<<endl<<endl;
  449.  
  450.   imprimir_sopa(w);
  451.   imprimir_encontradas(x, y);
  452.  
  453.   gotoxy(3,24);
  454.   textcolor(LIGHTGREEN);
  455.   cout<<"Felicitaciones! Has adivinado todas!"<<endl;
  456.   textcolor(WHITE);
  457.  
  458. }

No entiendo por qué aparecen lineas horizontales dentro del código... Qué debo hacer para hacerlo visible? Gracias de antemano. Saludos!



Ahora si :)


« Última modificación: 5 Agosto 2014, 15:57 pm por Eternal Idol » En línea

eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Problema guardando 2d arrays en binarios
« Respuesta #1 en: 5 Agosto 2014, 11:20 am »

No entiendo por qué aparecen lineas horizontales dentro del código... Qué debo hacer para hacerlo visible?

Para que el código aparezca "correcto" tienes que añadirle a la etiqueta "code" el lenguaje empleado:

code=cpp -> C++
code=c -> C
...

Si la etiquetas la dejas como "code" a secas al código se le da una interpretación que puede no ser la correcta... en tu caso [ s ] se está interpretando como texto tachado, por lo que te tacha todo lo que se encuentra entre esa etiqueta y la de cierre... que como no hay te tacha hasta el final del código.

No estoy muy seguro del código correspondiente a write y read

Código
  1. char sopa[20][20];
  2. arch.read(sopa[0], 20*20*sizeof(sopa));

Si sopa es un array bidimiensional... tu quieres sobreescribir dicho array al completo... ¿por qué accedes a sopa[0]? Si pretendes modificar "sopa"... el puntero que debes pasar es "sopa"... no "sopa[0]". Además, "20*20*sizeof(sopa)"... si sopa es un array de 20*20... entonces esa expresión es equivalente a "20*20*20*20*sizeof(char)"... y creo que no es tu intención leer semejante cantidad de información. Tienes que tener en cuenta que de la forma en la que has declarado el array, el compilador sabe en todo momento el tamaño de esa variable... que serán 400 bytes.

Dicho esto aquí tienes dos opciones:

Opción 1:

Código
  1. arch.read(sopa, sizeof(sopa));

Opción 2:

Código
  1. arch.read(sopa, 20*20*sizeof(char));

Yo, personalmente, prefiero la primera opción ya que si te da por cambiar el tamaño del array y te olvides de cambiar esta otra línea vas a tener errores en el código.

El resto de lecturas y escrituras presentan los mismos problemas.

Un saludo.


En línea

julianbesso1

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Re: Problema guardando 2d arrays en binarios
« Respuesta #2 en: 5 Agosto 2014, 14:50 pm »

Todavía estoy con problemas. Eferion, respecto a tus respuestas:

1)
Código
  1. arch.read(sopa, sizeof(sopa));
2)
Código
  1. arch.read(sopa, 20*20*sizeof(char));

Ambas devuelven el mismo error:

 no matching function for call to 'std::basic_fstream<char>::read(char[20][20], unsigned int)'

Intenté agregar (char *) de modo que quede de la siguiente manera:

Código
  1. arch.read((char *)sopa, sizeof(sopa));
Código
  1. arch.read((char *)sopa, 20*20*sizeof(char));

Lo cual "funciona", pero cuando quiero acceder al binario, me imprime en pantalla caracteres extraños...

Voy a seguir probando. Gracias!







Lo conseguí agregando la bandera ios::in y ios::out respectivamente. No sabía que eran cruciales para que pudiera escribirse o leerse un archivo.

Quedó de la siguiente manera:

Código
  1. arch.open("sopa saved.dat", ios::binary | ios::out);
  2.  
  3. arch.write((char *)sopa, 20*20*sizeof(char));
  4.  
  5. arch.write((char *)found, 5*4*sizeof(int));
  6.  
  7. arch.write((char *)lista, 5*21*sizeof(char));
  8.  
  9. arch.write((char *)palabras_found,sizeof(int));
  10.  
  11. arch.close();

El guardado sale perfecto, pero cuando ejecuto la opción de guardar dentro del programa este se detiene y me tira el cuadro de diálogo "sopa.exe ha dejado de funcionar" y tengo que cerrar...

Alguna solución para eso? Ya casi estoy :)

Gracias!!!

« Última modificación: 5 Agosto 2014, 15:57 pm por Eternal Idol » En línea

Swain

Desconectado Desconectado

Mensajes: 29



Ver Perfil
Re: Problema guardando 2d arrays en binarios
« Respuesta #3 en: 5 Agosto 2014, 15:59 pm »

Solo por comentar, es necesario usar in, out cuando no especificas a la hora de crear el puntero

para leer ifstream para guardar ofstream, si lo creas fstream necesitas especificar a la hora de hacer el open si vas a guardar o leer.

No te serviria guardar TODO dentro de una estructura y pasarla como binario al archivo y despues leerla??


algo como



Código
  1.  
  2. #define dir_work "archivo.dat"
  3.  
  4. struct MyFile{
  5.         char name[80];
  6.         char semilla[20][20];
  7.         int random;
  8.         bool pUp;
  9. }dd;
  10.  
  11. bool readInfo(){
  12.    ifstream inf(dir_work, ios::in | ios::binary);
  13.    if(!inf){
  14.        cout << "Archivo no existe" << endl;
  15.        return false;
  16.    }
  17.    inf.read((char *)&dd,sizeof(struct MyFile));
  18.    inf.close();
  19.    return true;
  20. }
  21. ////////////////////////////////////////////////////////////
  22. ////////////////////////////////////////////////////////////
  23. void saveInfo(){
  24.    ofstream outf(dir_work, ios::out | ios::binary);
  25.    outf.write((char *)&dd,sizeof(struct MyFile));
  26.    outf.close();
  27. }
  28.  
  29. int main(){
  30.  
  31. dd.random = rand() %100;
  32.  
  33. memcpy (dd.name,"Swain");
  34.  
  35. saveInfo(); // salvadira todos los datos que tengas en dd;
  36. readInfo(); // cargaria todos los datos que tengas en el archivo a dd;
  37.  
  38.  
  39.  
  40.  
  41. ...
  42.  
En línea

No me sigas.
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Problema guardando 2d arrays en binarios
« Respuesta #4 en: 5 Agosto 2014, 16:30 pm »

Código
  1. int palabras_found=0;
  2.  
  3. // ...
  4.  
  5. arch.write((char *)palabras_found,sizeof(int));

¿por qué motivo tratas palabras_found como si fuese un puntero? Me da que no terminas de entender el significado y funcionamiento de los punteros.

En este caso concreto, "palabras_found" no es puntero, y dado que la función "write" necesita un puntero, lo que tienes que facilitarle a la función es la posición de memoria donde se encuentra "palabras_found", es decir:

Código
  1. arch.write((char *)&palabras_found,sizeof(int));

Lo que tu estabas almacenando antes en el fichero era guarrería... además le estabas dando al sistema operativo motivos más que suficientes para que matase tu programa por acceder a memoria que no le corresponde.
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Problema con arrays en C#
.NET (C#, VB.NET, ASP)
Edu 4 4,273 Último mensaje 23 Noviembre 2010, 16:08 pm
por Edu
[C++] Problema con Arrays.. « 1 2 »
Programación C/C++
Wazzp 10 5,701 Último mensaje 16 Enero 2011, 20:33 pm
por Wazzp
[Batch] Convertidor decimal a binarios y binarios a decimal bien simple
Scripting
bITEBUG 0 2,841 Último mensaje 15 Junio 2011, 06:13 am
por bITEBUG
[C] Problema con Arrays.
Programación C/C++
edr89 6 3,256 Último mensaje 27 Mayo 2013, 20:49 pm
por leosansan
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines