Ir al contenido



Foto

Archivos


  • Por favor identifícate para responder
5 respuestas en este tema

#1 rodrigo_0910

rodrigo_0910

    Newbie

  • Miembros
  • Pip
  • 3 mensajes

Escrito 17 marzo 2014 - 07:52

Hola,

miren, fijense que tengo un problema: Tengo que hacer un codigo, en donde la consola me pida el que ingrese un archivo, que sera "Datos.txt" y el tiene ciertas instrucciones como:

Ingresar,101,Rodrigo,75,80
Ingresar,201,dsds,70,85
Ingresar,301,PS4,100,800

Eliminar,101,Rodrigo,75,80
Modificar,201,dsds,70,85


Lo que me piden es que se generen 2 archivos:

1) El archivo Salida.txt que contenga las instrucciones del Datos.txt pero como que en pasado, asi como:
Se ingreso: 101,Rodrigo,75,80
Se ingreso 201,dsds,70,85
Se ingreso: 301,PS4,100,800

Se elimino: 101,Rodrigo,75,80
Se modifico: 201,dsds,70,85

2) Un archivo binario "Maestro.dat" en donde los datos que se ingresen (que tienen que ser 777) sean ordenados conforme a su codigo ascii y que si la instruccion dice ingresar que lo ingrese, si dice eliminar que lo elimine y si dice modificar, que lo modifique.

Ya tengo algo avanzado el codigo, pero me falta la parte del binario, no se si me ayudan, el codigo esta aca:


cpp
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <conio.h>
  4. #include <stdlib.h>
  5. #include <iostream>
  6. #include <fstream>
  7. #include <cstring>
  8.  
  9. using namespace std;
  10.  
  11. struct Producto{
  12.     char cod[10];
  13.     char name[50];
  14.     char precio[10];
  15.     char cantidad[5];
  16. };
  17. struct Producto X;
  18. char Linea[200];
  19. FILE *out, *inn, *bin;
  20.  
  21. void generarArchivos(){
  22.     char ifilename[100];
  23.     char ofilename[] = "Salida.txt";
  24.     char bfilename[] = "Maestro.bin";
  25.  
  26.     printf("Ingrese Archivo de Entrada: ");
  27.     gets(ifilename);
  28.     printf("\n");
  29.  
  30.     inn = fopen(ifilename,"r");                  /* Abrir archivo entrada    */
  31.     strcpy(Linea," ");
  32.     strcat(Linea,X.cod);
  33.     strcat(Linea,",");
  34.     strcat(Linea,X.name);
  35.     strcat(Linea,",");
  36.     strcat(Linea,X.cantidad);
  37.     strcat(Linea,",");
  38.     strcat(Linea,X.precio);
  39.     strcat(Linea,",");
  40.     fputs(Linea,inn);
  41.  
  42.  
  43.     out = fopen(ofilename,"w");
  44.     while (fscanf(inn,"%s",Linea) != EOF) {
  45.         fprintf(out,"%s\n",Linea);
  46.     }
  47.     fclose(out);
  48.  
  49.     bin = fopen("Maestro.bin","w");
  50.    
  51. FILE* f = fopen("Datos.txt", "r");
  52.  
  53.   // Determine file size
  54. fseek(f, 0, SEEK_END);
  55. size_t size = ftell(f);
  56.  
  57.  
  58.   int length;
  59.   std::ifstream is ("Datos.txt", std::ifstream::binary);
  60.   if (is) {
  61.     // get length of file:
  62.     is.seekg (0, is.end);
  63. length  = is.tellg();
  64.     is.seekg (0, is.beg);
  65.  
  66.     // allocate memory:
  67.     char * buffer = new char [length];
  68.  
  69.     // read data as a block:
  70.     is.read (buffer,length);
  71.  
  72.     is.close();
  73.  
  74.     // print content:
  75.     std::cout.write (buffer,length);
  76.  
  77.     delete[] buffer;
  78.   }
  79.  
  80.  
  81.  
  82.  
  83.  
  84. char* alocar = new char[length];
  85.  
  86.  
  87.  
  88. rewind(f);
  89. fread(alocar, sizeof(char), size, f);
  90. //--------------
  91.  
  92.  
  93.  
  94. string str(alocar);
  95. //----------
  96.  
  97. int from=0;
  98.  
  99. int from1=0;
  100.  
  101.  
  102. int from2=0;
  103.  
  104. int from3=0;
  105.  
  106. int from4=0;
  107.  
  108. int to=0;
  109. int to1=0;
  110. int to2=0;
  111. int to3=0;
  112.  
  113. int to4=0;
  114.  
  115.  
  116.  
  117. string codigo="";
  118. string nombre="";
  119. string cantidad="";
  120. string precio="";
  121.  
  122. string nuevo="";//aqui va el nuevo string
  123.  
  124.  
  125. while(str.find("Ingresar") != string::npos){//encontrar ingresar
  126.  
  127. from=str.find("Ingresar");
  128. from1=  str.find(",",from+8);
  129. to1= str.find(",",from1+1);
  130.  
  131. codigo=str.substr(from1+1,to1-from1-1);
  132.  
  133. from2= str.find(",",from1+1);
  134. to2= str.find(",",from2+1);
  135.  
  136. nombre=str.substr(from2+1,to2-from2-1);
  137.  
  138. from3= str.find(",",from2+1);
  139. to3= str.find(",",from3+1);
  140.  
  141. precio=str.substr(from3+1,to3-from3-1);
  142.  
  143. from4= str.find(",",from3+1);
  144. to4= str.find("\n",from3);
  145.  
  146. cantidad=str.substr(from4+1,to4-from4-1);
  147.  
  148.  
  149.  
  150. //------------Add text
  151.  
  152.  
  153. printf("%s",codigo.c_str());
  154.  
  155. nuevo.append(codigo);
  156. nuevo.append(",");
  157. nuevo.append(nombre);
  158. nuevo.append(",");
  159. nuevo.append(precio);
  160. nuevo.append(",");
  161. nuevo.append(cantidad);
  162.  
  163. nuevo.append("\n");
  164.  
  165.  
  166. str.replace(str.find("Ingresar"),8,"holamundo");
  167.  
  168. }
  169.  
  170.  
  171. while(str.find("Eliminar") != string::npos){//encontrar ingresar
  172.  
  173. str.replace(str.find("Eliminar"), 8, "Se Elimino");
  174.  
  175. }
  176.  
  177. while(str.find("Modificar") != string::npos){//encontrar ingresar
  178.  
  179. str.replace(str.find("Modificar"), 9, "Se Modifico");
  180.  
  181. }
  182.  
  183. //------------RECEONVERTIR A CHAR ARRAY
  184.  
  185.  
  186. int TempNumOne=nuevo.length();
  187.     char * deressed = new char[TempNumOne];
  188.  
  189.  
  190. for (int a=0;a<=TempNumOne-1;a++)
  191.         {
  192.  
  193.  
  194.             deressed[a]=nuevo[a];
  195.         }
  196.  
  197.  
  198. //-----------
  199.  
  200.  
  201.     fwrite(deressed,sizeof(char),TempNumOne,bin);
  202.  
  203.     fclose(bin);
  204.     fclose(inn);
  205.  
  206. }
  207.  
  208. void leerDatos(){
  209.     inn = fopen("Datos.txt","r");
  210.     out = fopen("Salida.txt","r");
  211.     printf("\nEl contenido del archivo es: \n\n");
  212. while (feof(out) == 0)
  213. {
  214. fgets(Linea,50,out);
  215. printf("%s",Linea);
  216. }
  217. fclose(inn);
  218. fclose(out);
  219. }
  220.  
  221. int main(){
  222.     generarArchivos();
  223.     leerDatos();
  224.     return 0;
  225. }


Edito para ponerte las etiquetas de código.
  • 0

#2 escafandra

escafandra

    Advanced Member

  • Moderadores
  • PipPipPip
  • 3.615 mensajes
  • LocationMadrid - España

Escrito 18 marzo 2014 - 06:07

Bienvenido al foro, rodrigo_0910.

En primer lugar decirte que siendo nuevo pasa y lee las normas del foro y uso de las etiquetas para mensajes.

En segundo lugar, deberías poner títulos descriptivos a tus mensajes, de esa forma invitas a leer.

En tercer lugar veo que se trata de una tarea de escuela o algo así. No defines bien de lo que partes y a donde quieres llegar. Deberías exponer dudas concretas para obtener respuestas adecuadas.

Veo que muestras código, te has tomado la molestia de comenzar tu trabajo, probablemente lo has compilado pero te habrás dado cuenta que no hace nada.

Como no se cual es el enunciado de tu tarea y he visto que te has tomado interés en resolverla, te voy a echar una mano.

Analiza este código, trabaja con él y modificarlo para que se ajuste a tu necesidad real:


cpp
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <conio.h>
  4. #include <stdlib.h>
  5. #include <dir.h>
  6.  
  7. struct Producto{
  8.     int cod;
  9.     char name[50];
  10.     int precio;
  11.     int cantidad;
  12. };
  13.  
  14. //---------------------------------------------------------------------------
  15. #define MAX_P 777    // Máximo de productos
  16.  
  17. // Defino un array de productos
  18. Producto Productos[MAX_P] = {0};
  19.  
  20. void Ingresar(Producto P)
  21. {
  22.   int n;
  23.   // Buscamos un producto de código 0 para ingresarlo en ese lugar
  24.   for(n=0; n<MAX_P && Productos[n].cod; n++);
  25.   Productos[n] = P;
  26. }
  27.  
  28. void Eliminar(Producto P)
  29. {
  30.   int n;
  31.   // Buscamos el producto P
  32.   for(n=0; n<MAX_P && Productos[n].cod != P.cod; n++);
  33.   // Ascendemos todos los restantes en el array
  34.   for(; n<MAX_P-1; n++) Productos[n] = Productos[n+1];
  35.   // Marcamos el último con cod = 0
  36.   Productos[n].cod = 0;
  37. }
  38.  
  39. void Modificar(Producto P)
  40. {
  41.   int n;
  42.   // Buscamos el producto
  43.   for(n=0; n<MAX_P && Productos[n].cod != P.cod; n++);
  44.   // Lo modificamos.
  45.   Productos[n] = P;
  46. }
  47.  
  48. // Separamos el comendo y lo convertimos a producto
  49. ComandoToProducto(char* Cmd, Producto* P)
  50. {
  51.   char Comando[256];
  52.   strcpy(Comando, Cmd);
  53.   char* C = strtok(Comando, ",");
  54.   C = strtok(0, ",");
  55.   if(C) P->cod = atoi(C);
  56.   C = strtok(0, ",");
  57.   if(C) strcpy(P->name, C);
  58.   C = strtok(0, ",");
  59.   if(C) P->precio = atoi(C);
  60.   C = strtok(0, ",");
  61.   if(C) P->cantidad = atoi(C);
  62. }
  63.  
  64. // Generamos los archiuvos pedidos
  65. bool generarArchivos()
  66. {
  67.   FILE *out, *inn, *bin;
  68.   char ifilename[MAXPATH];
  69.   char ofilename[] = "Salida.txt";
  70.   char bfilename[] = "Maestro.bin";
  71.   char Comando[MAXPATH];
  72.  
  73.   printf("Ingrese Archivo de Entrada: ");
  74.   gets(ifilename);
  75.   printf("\n");
  76.  
  77.   Producto P;
  78.   inn = fopen(ifilename, "rt"); // Abrir archivo entrada
  79.   if(!inn){
  80.     printf("El archivo %s no existe, opruebe con otro\n\n", ifilename);
  81.     return false;
  82.   }
  83.  
  84.   out = fopen(ofilename, "wt"); // Abrir archivo salida
  85.  
  86.   do{
  87.     fgets(Comando, MAXPATH, inn);
  88.     ComandoToProducto(Comando, &P);
  89.     if(!strnicmp(Comando, "INGRESAR", 8)){
  90.       Ingresar(P);
  91.       fprintf(out, "Se ingresó: \t%s", Comando + 9);
  92.     }
  93.     else if(!strnicmp(Comando, "ELIMINAR", 8)){
  94.       Eliminar(P);
  95.       fprintf(out, "Se eliminó: \t%s", Comando + 9);
  96.     }
  97.     else if(!strnicmp(Comando, "MODIFICAR", 9)){
  98.       Modificar(P);
  99.       fprintf(out, "Se modificó: \t%s", Comando + 10);
  100.     }
  101.  
  102.   }while(!feof(inn));
  103.   fclose(inn);
  104.   fclose(out);
  105.  
  106.   // Guardar Binario
  107.   // Recorremos y guardamos el array de productos
  108.   bin = fopen(bfilename, "wt");
  109.   for(int n=0; n<MAX_P; n++)
  110.     fprintf(bin, "%d,%s,%d,%d\n", Productos[n].cod, Productos[n].name, Productos[n].precio, Productos[n].cantidad);
  111.   fclose(bin);
  112.  
  113.   return true;
  114. }
  115.  
  116. //---------------------------------------------------------------------------
  117. int main()
  118. {
  119.   while (!generarArchivos());
  120.   return 0;
  121. }


Saludos.


  • 0

#3 rodrigo_0910

rodrigo_0910

    Newbie

  • Miembros
  • Pip
  • 3 mensajes

Escrito 18 marzo 2014 - 03:42

Hola escafandra,

Muchas gracias por responderme, por invitarme a leer las normas y por aconsejarme de usar etiquetas para tener una mejor presentación en mis futuras publicaciones.

Primero, te quiero agradecer por proveerme un código que me sea de ayuda.

Segundo, para explicarte mejor el proyecto: Básicamente tengo que hacer una base de datos. El archivo Datos.txt tiene ingresadas ya las instrucciones. Es decir, si un dato lo debe de ingresar, eliminar o modificar. Cada dato tiene los campos: codigo, nombre, cantidad, precio. Bueno, entonces el programa debe de generar 2 archivos.

El primero sería el Salida.txt, en donde las instrucciones del archivo Datos.txt las escriba pero en pasado. Ingresar --> Se ingresó; Eliminar --> Se eliminó; Modificar --> Se modificó...

El segundo, es el Maestro.dat, que es en binario. En este archivo tienen que ir ingresados solo los datos, en forma de base de datos ordenados por código. Primero que vaya el dato 001, luego el dato 002, luego el dato 003 y así. La idea que se dio fue que se ordenara por el código ASCII. Tambíen, que si el archivo Datos.txt tiene la instrucción "Eliminar" que elimine el dato indicado, si dice Modificar, que modifique el dato indicado.

El código que yo puse, lamentablemente solo genera los 2 archivos, pero no ordena los datos en el archivo binario, ni cambia las palabras en e archivo Salida.txt.

Esperando que esto te haya orientado más, y que me podrías brindar un consejo o un ayuda, te agradecería.

Saludos







  • 0

#4 escafandra

escafandra

    Advanced Member

  • Moderadores
  • PipPipPip
  • 3.615 mensajes
  • LocationMadrid - España

Escrito 18 marzo 2014 - 07:15

No aclaras si debes usar una metodología concreta, si pretenden que uses C++ (Orientado a objetos) o sólo C, aunque veo que usas el operador new y otros elementos propios de C++. No se si debes usar clases o no. Tampoco aclaras si esa base de datos debe ser tratase directamente en disco con acceso aleatorio o te permiten el uso de un array como el ejemplo que te expuse. Todo esto va a estar muy en relación con lo que os hayan explicado en clase...

El ejemplo que publiqué usa un array de registros (producto) sobre el que trabajan los comandos de agregar, modificar o borrar. Lo que no hice fue ordenar por código de producto, que me parece que es el orden que te piden, en ausencia de un índice. Si sólo te permiten la escritura del archivo, sin usar arrays, tendrás que navegar por él.

Mi ejemplo usa enteros y cadenas en la estructura producto, no es difícil usar sólo caracteres. Si te sirve este ejemplo, puedes realizar ese cambio (si te obligan a ello)  y añadir una función de ordenación como puede ser un sencillo método de burbuja. También puedes usar un array de punteros a elementos producto que creas de forma dinámica, de esta forma es más sencillo insertar datos ya ordenados desde el inicio, sólo tendrías que buscar donde tienes que insertarlos.

Saludos.


  • 0

#5 rodrigo_0910

rodrigo_0910

    Newbie

  • Miembros
  • Pip
  • 3 mensajes

Escrito 18 marzo 2014 - 07:42

Puedo usar C++ o C (de preferencia C).

No sé si debo usar clases, el catedrático no dijo nada de eso. Y, no entiendo lo de "disco con acceso aleatorio" pero si me permiten el uso de array. Puedo usar strings también.

No es obligatorio usar caracteres para cada campo, yo lo pensé así porque si le asigno variable entero, en el código 001, solo leerá el 1. Cosa que sería perfecto si no utilizara ordenamiento por codigo ascii. Que sería lo más fácil.

Fíjate que compile tu programa, pero al llamar al archivo Datos.txt, la consola se bloquea. Y sale el mensaje de: "El programa ha dejado de funcionar", y tengo que cerrar la consola. No sé porque tira el error. Uso CodeBlocks, por cierto.

Saludos


  • 0

#6 escafandra

escafandra

    Advanced Member

  • Moderadores
  • PipPipPip
  • 3.615 mensajes
  • LocationMadrid - España

Escrito 19 marzo 2014 - 03:03

Lo compilé con CodeBlocks y el código funciona.

Lo he cambiado un poco para que cuando se ingrese un registro nuevo lo coloque ya ordenado por cod, que también lo puse en texto.


cpp
  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <conio.h>
  5. #include <stdlib.h>
  6. #include <dir.h>
  7.  
  8.  
  9. #define MAXPATH 256
  10.  
  11. //using namespace std;
  12.  
  13. struct Producto{
  14.     char cod[10];
  15.     char name[50];
  16.     int precio;
  17.     int cantidad;
  18. };
  19.  
  20. //---------------------------------------------------------------------------
  21. #define MAX_P 777    // Máximo de productos
  22.  
  23. // Defino un array de productos
  24. Producto Productos[MAX_P] = {0};
  25.  
  26. char* strnewdup(char* S)
  27. {
  28.   return strcpy(new char[strlen(S)+1], S);
  29. }
  30.  
  31. bool Ingresar(Producto P)
  32. {
  33.   int n;
  34.  
  35.   // Buscamos un lugar donde insertar ordenado el elemento
  36.   for(n=0; n<MAX_P && *Productos[n].cod && strcmp(Productos[n].cod, P.cod)<0; n++);
  37.   if(n == MAX_P) return false;
  38.  
  39. // Descendemos todos los elementos del array
  40.   for(int i= MAX_P-1; i>n; i--)
  41.     Productos[i] = Productos[i-1];
  42. // Insertamos
  43.   Productos[n] = P;
  44. }
  45.  
  46. void Eliminar(Producto P)
  47. {
  48.   int n;
  49.   // Buscamos el producto P
  50.   for(n=0; n<MAX_P && strcmp(Productos[n].cod, P.cod); n++);
  51.   // Ascendemos todos los restantes en el array
  52.   for(; n<MAX_P-1; n++) Productos[n] = Productos[n+1];
  53.   // Marcamos el último con cod = 0
  54.   *Productos[n].cod = 0;
  55. }
  56.  
  57. void Modificar(Producto P)
  58. {
  59.   int n;
  60.   // Buscamos el producto
  61.   for(n=0; n<MAX_P && strcmp(Productos[n].cod, P.cod); n++);
  62.   // Lo modificamos.
  63.   Productos[n] = P;
  64. }
  65.  
  66. // Separamos el comendo y lo convertimos a producto
  67. void ComandoToProducto(char* Cmd, Producto* P)
  68. {
  69.   char *Comando = strnewdup(Cmd);
  70.   char* C = strtok(Comando, ",");
  71.   C = strtok(0, ",");
  72.   if(C) strcpy(P->cod, C);
  73.   C = strtok(0, ",");
  74.   if(C) strcpy(P->name, C);
  75.   C = strtok(0, ",");
  76.   if(C) P->precio = atoi(C);
  77.   C = strtok(0, ",");
  78.   if(C) P->cantidad = atoi(C);
  79.   delete Comando;
  80. }
  81.  
  82. // Generamos los archiuvos pedidos
  83. bool generarArchivos()
  84. {
  85.   FILE *out, *inn, *bin;
  86.   char ifilename[MAXPATH];
  87.   char ofilename[] = "Salida.txt";
  88.   char bfilename[] = "Maestro.bin";
  89.   char Comando[MAXPATH];
  90.  
  91.   printf("Ingrese Archivo de Entrada: ");
  92.   gets(ifilename);
  93.   printf("\n");
  94.  
  95.   Producto P;
  96.   inn = fopen(ifilename, "rt"); // Abrir archivo entrada
  97.   if(!inn){
  98.     printf("El archivo %s no existe, pruebe con otro\n\n", ifilename);
  99.     return false;
  100.   }
  101.  
  102.   out = fopen(ofilename, "wt"); // Abrir archivo salida
  103.  
  104.   do{
  105.     fgets(Comando, MAXPATH, inn);
  106.     ComandoToProducto(Comando, &P);
  107.     if(!strnicmp(Comando, "INGRESAR", 8)){
  108.       Ingresar(P);
  109.       fprintf(out, "Se ingresó: \t%s", Comando + 9);
  110.     }
  111.     else if(!strnicmp(Comando, "ELIMINAR", 8)){
  112.       Eliminar(P);
  113.       fprintf(out, "Se eliminó: \t%s", Comando + 9);
  114.     }
  115.     else if(!strnicmp(Comando, "MODIFICAR", 9)){
  116.       Modificar(P);
  117.       fprintf(out, "Se modificó: \t%s", Comando + 10);
  118.     }
  119.  
  120.   }while(!feof(inn));
  121.   fclose(inn);
  122.   fclose(out);
  123.  
  124.   // Guardar Binario
  125.   // Recorremos y guardamos el array de productos
  126.   bin = fopen(bfilename, "wt");
  127.   for(int n=0; n<MAX_P; n++)
  128.     fprintf(bin, "%s,%s,%d,%d\n", Productos[n].cod, Productos[n].name, Productos[n].precio, Productos[n].cantidad);
  129.   fclose(bin);
  130.  
  131.   return true;
  132. }
  133.  
  134. //---------------------------------------------------------------------------
  135. int main(int argc, char* argv[])
  136. {
  137.  
  138.   // Ajustamos el directorio de trabajo
  139.   char *D = strnewdup(argv[0]);
  140.   char *C = strrchr(D, '\\'); if(C) *++C=0;
  141.   chdir(D);
  142.   delete D;
  143.  
  144.   // Comenzamos
  145.   while (!generarArchivos());
  146.   return 0;
  147. }


Este código puede ser más eficiente si se usa un array de puntros en lugar de productos, pero no te quiero liar más.
A partir de él, cuando lo entiendas, podrás realizar los cambios que quieras.


Saludos.
  • 0