Autor Tema: Escr Y Leer Una Clase En Un File Aleatorio En C++ (Leído 7057 veces)

maikmr · « **en:** Viernes 3 de Junio de 2005, 00:24 »

Supongamos que tengo la sig. clase:
[/CODE]
Class arch_aleatorio{
char nombre [20];
int edad;

public:
void escribir();
void leer();
};
[CODE]
Les agradeseria si alguien me pudiera dar un ejemplo de como hacer lecturas y escrituras en un archivo de acceso aleatorio, basandose en una clases cualquiera como esta por ejemplo. ¿Cuales seria los parametrios correcto para crear el archivo? y todo lo que implica ios:: ?.

De antemano gracias, por cualquier ayuda brindada.!

pitukilloloco

Yo te podría dar un ejemplo pero usando las funciones de la librería estándar cuyo encabezado es stdio.h. Las funciones para manejar flujos que están definidas en iostream.h (donde está definida la clase ios) siempre me ha dado flojera estudiar cómo funcionan pues cuando quiero escribir y leer de un archivo con las primeras funciones que te menciono me ha bastado. El mismo creador del lenguaje Bjarne Stroustrup, reconoce en su libro El Lenguaje de Programación C++ que las funciones de flujo son más seguras con respecto a los tipos pero que las de stdio.h son más sencillas de manejar.

maikmr

Ok! le agradeseria que me pase el ejemplo, su pongamos que la clases que puse arriba es un struct como mando a escribir y leer las estructura completa en un archivo de acceso aleatorio!.

Gracias por su ayuda!!

pitukilloloco

Este es un ejemplo sencillo que hice que da de alta el nombre y la matrícula de un alumno. Lo puedes modificar fácilmente para que utilices la estructura que quieres. En el ejemplo muestro cómo dar de alta, de baja y modificar un alumno. Al dar de baja sólo estoy poniendo una marca de borrado pero no estoy en realidad borrando el alumno del archivo. Esto lo puedes hacer pasando todos los registro que no tengan la marca a un nuevo archivo, borrar el original y renombrar el nuevo. Ya no hice esto porque el ejemplo lo quise hacer lo más sencillo posible.

Código: Text

 
#include &#60;stdio.h&#62;
#include &#60;stdlib.h&#62;
#include &#60;string.h&#62;
 
enum { FALSO = 0, VERDADERO = 1 };
#define BAJA -1
 
struct alumno {
  char nombre [80];
  int matricula;
};
 
FILE *globfp;
 
void AbreBase (char *nombase)
{
  if ((globfp = fopen (nombase, &#34;r+b&#34;)) == NULL)
    if ((globfp = fopen (nombase, &#34;w+b&#34;)) == NULL) {
      fprintf (stderr, &#34;Error al crear el archivo %s&#092;n&#34;, nombase);
      exit (EXIT_FAILURE);
    }
}
 
void CierraBase ()
{
  fclose (globfp);
}
 
int Alta (char *nombre, int matricula)
{
  struct alumno a;
 
  strcpy (a.nombre, nombre);
  a.matricula = matricula;
 
  fseek (globfp, 0L, SEEK_END);
  fwrite (&a, sizeof (a), 1, globfp);
 
  return VERDADERO;
}
 
int Modifica (int matri, char *nombre, int matricula)
{
  struct alumno a;
 
  fseek (globfp, 0L, SEEK_SET);
  while (VERDADERO) {
    fread (&a, sizeof (a), 1, globfp);
    if (feof (globfp))
      break;
    if (a.matricula == matri) {
      strcpy (a.nombre, nombre);
      a.matricula = matricula;
      fseek (globfp, -1L * sizeof (a), SEEK_CUR);
      fwrite (&a, sizeof (a), 1, globfp);
      return VERDADERO;
    }
  }
  return FALSO;
}
 
int Baja (int matricula)
{
  return Modifica (matricula, &#34;&#34;, BAJA);
}
 
void VerBase ()
{
  struct alumno a;
 
  fseek (globfp, 0L, SEEK_SET);
  while (VERDADERO) {
    fread (&a, sizeof (a), 1, globfp);
    if (feof (globfp))
      break;
    if (a.matricula != BAJA)
      printf (&#34;#%d&#092;t%s&#092;n&#34;, a.matricula, a.nombre);
  }
}
 
int main ()
{
  char *datos[] = {
    &#34;Pepa&#34;, &#34;1&#34;,
    &#34;Pepe&#34;, &#34;2&#34;,
    &#34;Ana&#34;, &#34;3&#34;,
    &#34;Pablo&#34;, &#34;4&#34;,
    &#34;Eva&#34;, &#34;5&#34;,
    &#34;Tito&#34;, &#34;6&#34;,
    &#34;Ema&#34;, &#34;7&#34;,
    &#34;Quico&#34;, &#34;8&#34;,
    &#34;Ines&#34;, &#34;9&#34;,
    &#34;Pedro&#34;, &#34;10&#34;,
  };
  int i;
 
  AbreBase (&#34;mibase.bin&#34;);
  for (i = 0; i &#60; sizeof (datos) / sizeof (*datos); i += 2)
    Alta (datos[i], atoi (datos[i + 1]));
 
  printf (&#34;--------------- &#34;);
  printf (&#34;Alumnos dados de alta&#092;n&#34;);
  VerBase ();
  Modifica (1, &#34;Pepa Luna&#34;, 100);
  Modifica (5, &#34;Eva Sol&#34;, 500);
  Modifica (10, &#34;Pedro Estrella&#34;, 1000);
  Baja (2);
  Baja (8);
  printf (&#34;--------------- &#34;);
  printf (&#34;Base de datos despu&#092;x82s de modificar y dar de baja&#092;n&#34;);
  VerBase ();
  CierraBase ();
 
  exit (EXIT_SUCCESS);
}
 
 

maikmr

Hombre se le agradece un monton por el ejemplo, asi da gusto ser parte de un foro.
muchas gracias.

Saludos desde Costa Rica!

maikmr

Código: Text

 
int Alta (char *nombre, int matricula)
{
  struct alumno a;
 
  strcpy (a.nombre, nombre);
  a.matricula = matricula;
 
  fseek (globfp, 0L, SEEK_END);// el parametro que coloca aqui 0L no se para que sirve
  fwrite (&a, sizeof (a), 1, globfp);
 
  return VERDADERO;
}
 
int Modifica (int matri, char *nombre, int matricula)
{
  struct alumno a;
 
  fseek (globfp, 0L, SEEK_SET);
  while (VERDADERO) {
    fread (&a, sizeof (a), 1, globfp);
    if (feof (globfp))
      break;
    if (a.matricula == matri) {
      strcpy (a.nombre, nombre);
      a.matricula = matricula;
      fseek (globfp, -1L * sizeof (a), SEEK_CUR);
      fwrite (&a, sizeof (a), 1, globfp);
      return VERDADERO;
    }
  }
  return FALSO;
}
 
 

Hasta Donde me parece espero equivocarme el metodo Alta hace una EScritura secuencial asi como el metodo Modifica hace una lectura secuancial(hasta que matri sea igual a el valor de matricual de la estructura).

Yo estoy trabajando con un archivo con indexacion Hash la formula hash me da la posicion en el archivo donde debo escribir asi como cuando quiero leer, por lo que me parece que su ejemplo no es el mejor sin pretender menos prestigiar su ayuda y su ejemplo ante todo. si ud o otra persona tiene un ejemplo que se pueda acoplar mejor con la indexacion hash, Se los agradecere.

pitukilloloco

Bueno, con el ejemplo yo sólo pretendía que supieras cómo usar las funciones de la librería estándar de entrada y salida de C, las funciones para abrir (fopen), cerrar (fclose), leer (fread) y escribir (fwrite) en un archivo, y de paso también te mostré cómo posicionarte en algún punto del archivo con la función fseek. En base a estas funciones (y a otras que no mostré aquí pero que puedes investigar en cualquier libro de texto o en internet, como ferror, fflush, etc.) puedes construir tu base de datos como lo desees ya sea usando índices con el método hash que mencionas, pero hay otras formas de hacerlo como usar índices por medio de un árbol binario, por árboles-B, etc., pero entonces, ya no te estaría poniendo un ejemplo sino te estaría resolviendo tu ejercicio, aparte que nunca mencionaste que ibas a usar índices ni que ibas a usar el método hash. Aquí está textualmente lo que pusiste al principio de tu duda en este foro

Citar

Les agradeseria si alguien me pudiera dar un ejemplo de como hacer lecturas y escrituras en un archivo de acceso aleatorio, ...

¿no creerás que soy adivino, verdad?

maikmr

No Todo esta bien, como dige, le agradesco por su colaboracion, y como ud mismo lo meciona tampoco pretendo que me den echo al piede la letra el programa que necesito hacer, lo que pasa es que no e podido mandar a escribir a la posicion en espesifico que me indica la formula hash, ah!(Los arbloes B y binarios que meciono tambien estan implicados en el trabjo que realizo solo que con estos la escritura en los archivo es mas secuncial y no tan directa como lo debe de se el de indexacion hash).

De verdad no valla a pensar que estoy menospreciando su ayuda, de verdad se lo agradescos aqui le voy a mostrar el fragmento de codigo con el que estoy tratando de mandar a escribir:

Código: Text

 
char tmp[4];        //En esta var se carga el numero de asegurado que capto de teclado.
cin &#62;&#62; tmp;
call.num_asegurado = str_a_integer(tmp);
 /*call es una var tipo de la struct llamanda persona (struct persona) que estoy tratando de mandar a escribir. y str_a_integer() es una funcion que me combierto de caracteres a un valor entero.*/ 
 
n_reg = hashs(tmp); /*n_reg es una var long en donde queda el valor que retorna la funcion hash*/
cout &#60;&#60; n_reg &#60;&#60;&#34;&#092;n&#34;;
 
fseek(ptr_file, (long)n_reg*sizeof(struct persona), 0);
fwrite(&call, sizeof(struct persona), 1, ptr_file);
//ptr_file es el puntero al archivo.
 
/*de esta forma es que estoy trantando de mandar a escribir, solo que obiamente no sirve Como lo se?
Facil la funcion ftell me retorna -1 indicandome que hay un error*/
long log = ftell(ptr_file);
 
 

En resumen lo que yo queria y si lo admito no mencione es un ejemplo que mande a escribir directamente asi como leer una clase o estructura a una posicion cualquiera en el archivo en la 20 en la 30,90 o 100 en la que sea!

ASi que si aun me quiere ayudar o alguna otra lo quiere hacer se los voy a agradecer mucho, como siempre esta clases de error alfinal resulta que era muy faciles, pero yo ya llevo 5 dias contando desde hoy para atras pegado en este problema.
Gracias Saludos.

pitukilloloco

Si te fijas en el código que te puse, al modificar una persona, encuentra a esta buscando secuencialmente en el archivo su matricula. ¿qué sucede si la encuentra? pues tengo que utilizar a la función fseek para regresar el apuntador al archivo (un apuntador que se usa internamente en las operaciones de lectura y escritura) al comienzo de donde se encuentra el alumno, ya que al leerlo este apuntador se incrementa hasta el total de bytes leídos. Esto lo hago con la instrucción

Código: Text

 
      fseek (globfp, -1L * sizeof (a), SEEK_CUR);

¿qué significa esto? pues que estoy moviendo hacia atrás (por eso lo multiplico por -1) el apuntador al archivo tantos bytes como haya en la estructura a, a partir de la posición actual del apuntador del archivo, esto lo indico con la constante SEEK_CUR, lo cual quiere decir que estoy haciendo un desplazamiento relativo a donde se encuentra el apuntador del archivo. Si tu quieres moverte a la posición donde se encuentra, por ejemplo el alumnoi #8, entonces tengo que hacer un desplazamiento absoluto del apuntador al archivo, a partir del comienzo. Esto se consigue de esta manera

Código: Text

 
      fseek (globfp, (8 - 1) * sizeof (a), SEEK_SET);

En general, si tu tienes declarada alguna estructura y tienes almacenado en disco elementos de ella, la manera para accesar al elemento n de ella es

Código: Text

 
      fseek (fp, (n - 1) * sizeof (struct nombre_strut), SEEK_SET);

espero que esta información te ayude con tu problema. Lo de implementar índices hash es relativamente sencillo, pero sobre todo laborioso, pero si piensas implementar árboles-B estos no son de ningún modo sencillos de implementar y los algoritmos para implementar las altas, bajas y modificaciones son muy complejos. Si te interesa por ahí tengo un libro ya viejo sobre estructuras de datos en C en donde viene un sencillo ejemplo de un programa en C y que implementa un árbol-B en disco, sólo que tendría que capturarlo y quizá hasta mañana te lo tendría.

maikmr

Ok! me espero entonces hasta mañana por este otro ejemplo, gracias seguirse tomando la molestia voy a sentarme a analizar otra vez el codigo de ejmplo que me habia puesto junto con el ultimo comentario, cualquier cosa por ahi voy a seguir molestando.

Al, como ve la sintaxis de las funciones fseek y fread estaran corectas?
creo que si, pero no se donde estare fallando.

maikmr

Ok! me espero entonces hasta mañana por este otro ejemplo, gracias seguirse tomando la molestia voy a sentarme a analizar otra vez el codigo de ejmplo que me habia puesto junto con el ultimo comentario, cualquier cosa por ahi voy a seguir molestando.

pitukilloloco · « **Respuesta #11 en:** Lunes 6 de Junio de 2005, 22:07 »

Bueno, lo prometido es deuda. Te pongo el código que maneja un árbol-B en disco. El programa lo saqué del libro Programs and Data Structures in C del autor Leendert Ammeraal. En él sólo introduce enteros en los nodos del árbol, pero tú lo podrías modificar fácilmente para que introduzca otras cosas. El fuente está escrito siguiendo el modelo K&R, o sea, como se escribían los programas antes de que se hiciera estándar el ANSI C, por lo que si quieres que el programa te compile sin error debes de modificar las banderas para que compile en modo K&R. Sólo lo capturé y probé que compilaba sin errores pero no le he corrido para ver si hace bien los árboles, por lo que debes de probarlo antes de incorporarlo a tu proyecto.

Código: Text

 
/* DISKTREE.C:
  Demonstration program for a B-tree on disk.
  After building the tree by reading integer from a
  file, we can repeteadly search the three for a
  given integer. Each time, a search path from root
  to leaf is displayed. We can also update the B-three
  interactively
*/
#include &#60;stdio.h&#62;
#include &#60;ctype.h&#62;
#define M 2
#define MM 4
#define NIL (-1L)
struct node { int cnt; key[MM]; long ptr[MM+1]; };
typedef struct node NODE;
NODE rootnode;
long start[2], root = NIL, freelist = NIL;
FILE *fptree;
 
main ()
{  int x;
  char ch, inpfilnam[30], treefilnam[30];
  FILE *fpinp;
 
  printf (&#34;Enter name of (binary) file for the B-tree; &#34;);
  scanf (&#34;%s&#34;, treefilnam);
  fptree = fopen (treefilnam, &#34;rb+&#34;);    /* rb+ and wb+  */
  if (fptree == NULL)            /* are system  */
  {  fptree = fopen (treefilnam, &#34;wb+&#34;);  /* dependent  */
    wrstart ();
  } else rdstart ();
 
  printf (&#34;Enter name of (ASCII) input file (or NONE) : &#34;);
  scanf (&#34;%s&#34;, inpfilnam);
  fpinp = fopen (inpfilnam, &#34;r&#34;);
  if (fpinp != NULL)
  {  while (fscanf (fpinp, &#34;%d&#34;, &x) &#62; 0) insert (x);
    fclose (fpinp);
  }
 
  while (1)
  {  printf (
    &#34;&#092;nDelete (D), Insert (I), Search (S) or Quit (Q): &#34;);
    do
    {  ch = getchar (); ch = toupper (ch);
    } while (ch != 'D' && ch != 'I' &&
          ch != 'S' && ch != 'Q');
    if (ch == 'Q') break;
    printf (&#34;Enter an integer: &#34;); scanf (&#34;%d&#34;, &x);
    switch (ch)
    {  case 'D': delete (x); break;
      case 'I': insert (x); break;
      case 'S': search (x); break;
    }
  }
  wrstart ();
  fclose (fptree);
}
 
search (x) int x;
{  int i, j, *k, n;
  NODE nod;
  long t = root;
  printf (&#34;Trace:&#092;n&#34;);
  while (t != NIL)
  {  readnode (t, &nod);
    k = nod.key; n = nod.cnt;
    for (j = 0; j &#60; n; j++) printf (&#34;%d&#34;, k[j]);
    printf (&#34;&#092;n&#34;);
    i = binsearch (x, k, n);
    if (i &#60; n && x == k[i]) { found (t, i); return; }
    t = nod.ptr[i];
  }
  notfound (x);
}
 
int binsearch (x, a, n) int x, *a, n;
/* Search array a[0], a[1], ..., a[n-1] for x    */
/* Returned value:  0 if x &#60;= a[0],  n if x &#62; a[n-1],*/
/*          or r, where a[r-1] &#60; x &#60;= a[r]  */
{  int i, left, right;
  if (x &#60;= a[0]) return 0;
  if (x &#62; a[n-1]) return n;
  left = 0; right = n-1;
  while (right - left &#62; 1)
  {  i = right + left &#62;&#62; 1;
    if (x &#60;= a[i]) right = i; else left = i;
  }
  return right;
}
 
found (t, i) long t; int i;
{  NODE nod;
  printf (&#34;Found in position %d &#34;, i);
  printf (&#34;of node with contents: &#34;);
  readnode (t, &nod);
  for (i = 0; i &#60; nod.cnt; i++) printf (&#34; %d&#34;, nod.key[i]);
  printf (&#34;&#092;n&#34;);
}
 
notfound (x) int x;
{  printf (&#34;Item %d not found&#092;n&#34;, x);
}
 
insert (x) int x;
/*  Driver function for node insertion, called only in the
  main program. Most of the work is delegated to 'ins'
*/
{  long tnew, u, getnode ();
  int xnew, code;
  code = ins (x, root, &xnew, &tnew);
  if (code == 2) printf (&#34;Duplicate key %d ignored&#092;n&#34;, x);
  if (code) return;
  u = getnode ();
  rootnode.cnt = 1; rootnode.key[0] = xnew;
  rootnode.ptr[0] = root; rootnode.ptr[1] = tnew;
  root = u;
  writenode (u, &rootnode);
}
 
int ins (x, t, y, u) int x, *y; long t, *u;
/*  Insert x in B-tree with root t. If not completely
  successful, the integer *y and the pointer *u
  remain to be inserted.
  Returned value:
    0 if insertion not completely successful.
    1 if insertion successful.
    2 if x is already present in B-tree.
*/
{  long tnew, getnode (), p_final, *p;
  long i, j, xnew, k_final, *n, *k, code;
  NODE nod, newnod;
  /*  Examine whether t is a pointer field in a leaf:
  */
  if (t == NIL) { *u = NIL; *y = x; return 0; }
 
  readnode (t, &nod);
        n = &nod.cnt; k = nod.key; p = nod.ptr;
 
  /* Select pointer p[i] and try to insert x in
    the subtree of which p[i] is the root;
  */
  i = binsearch (x, k, *n);
  if (i &#60; *n && x == k[i]) return 2;  /* Duplicate key */
  code = ins (x, p[i], &xnew, &tnew);
  if (code) return code;
 
  /* Insertion in subtree did not completely succed;
    try to insert xnew and tnew in the current node:
  */
  if (*n &#60; MM)
  {  i = binsearch (xnew, k, *n);
    for (j = *n; j &#62; i; j--)
    {  k[j] = k[j-1]; p[j+1] = p[j];
    }
    k[i] = xnew; p[i+1] = tnew; ++*n;
    writenode (t, &nod); return 1;
  }
 
  /* The current node was already full, so split it. Pass
    item k[M] in the middle of the augmented sequence
    back through parameter y, so that it can move
    upward in the tree. Also, pass a pointer to the newly
    created node back through u. Return 0, to report
    that insertion was not completed:
  */
  if (i == MM) { k_final = xnew; p_final = tnew; } else
  {  k_final = k[MM-1]; p_final = p[MM];
    for (j = MM-1; j &#62; i; j--)
    {  k[j] = k[j-1]; p[j+1] = p[j];
    }
    k[i] = xnew; p[i+1] = tnew;
  }
  *y = k[M]; *n = M;
 
  *u = getnode (); newnod.cnt = M;
  for (j = 0; j &#60; M-1; j++)
  {  newnod.key[j] = k[j+M+1]; newnod.ptr[j] = p[j+M+1];
  }
  newnod.ptr[M-1] = p[MM]; newnod.key[M-1] = k_final;
  newnod.ptr[M] = p_final;
  writenode (t, &nod); writenode (*u, &newnod); return 0;
}
 
long getnode ()
{  long t;
  NODE nod;
  if (freelist == NIL)
  {  if (fseek (fptree, 0L, 2)) error (&#34;fseek in getnode&#34;);
    t = ftell (fptree);
    writenode (t, &nod);  /* Reserve space on disk */
  } else
  {  t = freelist;
    readnode (t, &nod);  /* To update freelist */
    freelist = nod.ptr[0];
  }
  return t;
}
 
freenode (t) long t;
{  NODE nod;
  readnode (t, &nod);
  nod.ptr[0] = freelist;
  freelist = t;
  writenode (t, &nod);
}
 
readnode (t, pnode) long t; NODE *pnode;
{  if (t == root) { *pnode = rootnode; return; }
  if (fseek (fptree, t, 0)) error (&#34;fseek in readnode&#34;);
  if (fread (pnode, sizeof (NODE), 1, fptree) == 0)
    error (&#34;fread in readnode&#34;);
}
 
writenode (t, pnode) long t; NODE *pnode;
{  if (t == root) rootnode = *pnode;
  if (fseek (fptree, t, 0)) error (&#34;fseek in writenode&#34;);
  if (fwrite (pnode, sizeof (NODE), 1, fptree) == 0)
    error (&#34;fwrite in writenode&#34;);
}
 
rdstart ()
{  if (fseek (fptree, 0L, 0)) error (&#34;fseek in rdstart&#34;);
  if (fread (start, sizeof (long), 2, fptree) == 0)
    error (&#34;fread in rdstart&#34;);
  readnode (start[0], &rootnode);
  root = start[0]; freelist = start[1];
}
 
wrstart ()
{  start[0] = root; start[1] = freelist;
  if (fseek (fptree, 0L, 0)) error (&#34;fseek in wrstart&#34;);
  if (fwrite (start, sizeof (long), 2, fptree) == 0)
    error (&#34;fwrite in wrstart&#34;);
  if (root != NIL) writenode (root, &rootnode);
}
 
error (str) char *str;
{  printf (&#34;&#092;nError: %s&#092;n&#34;, str);
  exit (1);
}
 
delete (x) int x;
/* Driver function for node deletion called only in the
  main program. Most of the work is delegated to &#34;del&#34;.
*/
{  int code;
  long newroot;
  code = del (x, root);
  if (code == 2) printf (&#34;%d not found&#092;n&#34;, x);
  if (code) return;
  /* 0 = underflow; 1 = success; 2 = key not found   */
  /* If underflow, decrease the height of the three: */
  newroot = rootnode.ptr[0]; freenode (root);
  if (newroot != NIL) readnode (newroot, &rootnode);
  root = newroot;
}
 
int del (x, t) int x; long t;
/* Delete item x in B-tree with root t.
   Returned value:
   0 = underflow, 1 = success, 2 = not found
*/
{  int i, j, *k, *n, *item, code,
    *nleft, *nright, *lkey, *rkey, borrowleft, nq, *addr;
  long *p, left, right, *lptr, *rptr, q, q1;
  NODE nod, nod1, nod2;
  if (t == NIL) return 2;
  readnode (t, &nod);
  n = &nod.cnt; k = nod.key; p = nod.ptr;
  i = binsearch (x, k, *n);
  if (p[0] == NIL)  /* *t is a leaf */
  {  if (i == *n || x &#60; k[i]) return 2;
    /* x is now equal to k[i], located in a leaf: */
    for (j = i+1; j &#60; *n; j++)
    {  k[j-1] = k[j]; p[j] = p[j+1];
    }
    --*n;
    writenode (t, &nod);
    return *n &#62;= (t == root ? 1 : M);
  }
  /* *t is an interior node (not a leaf): */
  item = k+i; left = p[i]; readnode (left, &nod1);
  nleft = &nod1.cnt;
  if (i &#60; *n && x == *item)
  { /* x found in interior node.             */
    /* Go to left child *p[i] and then follow a path   */
    /* all the way to a leaf, using rightmost branches */
    q = p[i]; readnode (q, &nod1); nq = nod1.cnt;
    while (q1 = nod1.ptr[nq], q1 != NIL)
    {  q = q1; readnode (q, &nod1); nq = nod1.cnt;
    }
    /* Exchange k[i] with the rightmost item in
      that leaf:
    */
    addr = nod1.key + nq - 1;
    *item = *addr; *addr = x;
    writenode (t, &nod); writenode (q, &nod1);
  }
  /* Delete x in subtree with root p[i] */
  code = del (x, left);
  if (code) return code;
  /* Underflow: borrow, and, if necessary, merge */
  borrowleft = i == *n;
  if (borrowleft)  /* p[i] is rightmost pointer in *p */
  {  item = k+i-1; left = p[i-1]; right = p[i];
    readnode (left, &nod1);
    nleft = &nod1.cnt;
  } else right = p[i+1];
  readnode (left, &nod1);
  readnode (right, &nod2);
  nright = &nod2.cnt;
  lkey = nod1.key; rkey = nod2.key;
  lptr = nod1.ptr; rptr = nod2.ptr;
  if (borrowleft)  /* This is an exception */
  {  rptr[*nright + 1] = rptr[*nright];
    for (j = *nright; j &#62; 0; j--)
    {  rkey[j] = rkey[j-1];
      rptr[j] = rptr[j-1];
    }
    ++*nright;
    rkey[0] = *item; rptr[0] = lptr[*nleft];
    *item = lkey[*nleft - 1];
    if (--*nleft &#62;= M)
    {  writenode (t, &nod); writenode (left, &nod1);
      writenode (right, &nod2);
      return 1;
    }
  } else
  if (*nright &#62; M)  /* Borrow from right sibling: */
  {  lkey[M-1] = *item; lptr[M] = rptr[0]; *item = rkey[0];
    ++*nleft; --*nright;
    for (j = 0; j &#60; *nright; j++)
    {  rptr[j] = rptr[j+1]; rkey[j] = rkey[j+1];
    }
    rptr[*nright] = rptr[*nright + 1];
    writenode (t, &nod); writenode (left, &nod1);
    writenode (right, &nod2);
    return 1;
  }
  /* Merge */
  lkey[M-1] = *item; lptr[M] = rptr[0];
  for (j = 0; j &#60; M; j++)
  {  lkey[M+j] = rkey[j]; lptr[M+j+1] = rptr[j+1];
  }
  *nleft = MM;
  freenode (right);
  for (j = i+1; j &#60; *n; j++) { k[j-1] = k[j]; p[j] = p[j+1]; }
  --*n;
  writenode (t, &nod);
  writenode (left, &nod1);
  return *n &#60;= (t == root ? 1 : M);
}
 
 

maikmr

Pituquillo! una vez mas se le agradese su desinteresada ayuda solo que continuo con un problema, ud dice que lo compilo, y que para complilarlo hay que cambiarle las banderas, por el estandar. Perdone que lo moleste tanto pero es que des conosco este estandar solo conosco el ANSI C, entonces si no fuera ya demaciado, me podria decir que es lo que hay que hacer con exactitud para que el codigo compile, pues lo intente compilar asì tal y como esta y me genero 26 errores. Obios Por lo del estandar.
Espero ya no tener despes de esto molestarlo mas, pues ya esta hasta pena me esta dando joder ya tanto!
Gracias

pitukilloloco

Acabo de leer tu mensaje y primeramente me tienes que decir que compilador usas pues el cambiar el modo de compilación a K&R depende de eso. Me puse a compilar de nuevo el programa y me di cuenta que había cometido dos errores (puede haber más pero no los he encontrado) al capturar. Estos son:
En las primeras líneas, despues del último #define hay que cambiar esta línea

Código: Text

 
struct node { int cnt; key[MM]; long ptr[MM+1]; };

por esta otra

Código: Text

 
struct node { int cnt, key[MM]; long ptr[MM+1]; };

(puse punto y coma en vez de poner sólo una coma). Y en la función ins, en la declaración de las variables, hay que cambiar la segunda línea

Código: Text

 
  long i, j, xnew, k_final, *n, *k, code;

por esta otra

Código: Text

 
  int i, j, xnew, k_final, *n, *k, code;

(puse long en vez de int)
Lo compilé sin errores ni advertencias con el Turbo C V2.01
Una de las diferencias de ANSI C con K&R es que en ANSI C debes de declarar a las funciones antes de poder usarlas, mientras que en K&R si una función no está declarada antes, el compilador asume que esta función regresa un valor entero. Otra diferencia es que al declarar o definir una función los tipos de los parámetros deben de darse dentro de los paréntesis de ANSI C, mientras que en K&R deben de darse afuera de los paréntesis. Otra diferencia es que en ANSI C debes de poner necesariamente el tipo que regresa la función, y en caso de que no regrese valor alguno, anteponer la palabra reservada void para indicar esto. En K&R, cuando no le pones el tipo que regresa la función se asume que regresa un entero. Por cierto la palabra reservada void no existe como tal en K&R. Existen otras muchas diferencias más pero estas son las más importantes para que cambies este programa que te puse a ANSI C. Me puse a hacerlo y te paso de nuevo el programa, con la correciones mencionadas al principio y para que compile en ANSI C. Sólo tuve que cambiar el nombre de la función delete por el nombre borrar para que no se confundiera con la palabra reservada de C++ que lleva el mismo nombre. El programa lo compilé con el Visual C++ 6 y con el Dev C++ sin ningún error.

Código: Text

 
#include &#60;stdio.h&#62;
#include &#60;ctype.h&#62;
#include &#60;stdlib.h&#62;
#define M 2
#define MM 4
#define NIL (-1L)
struct node { int cnt, key[MM]; long ptr[MM+1]; };
typedef struct node NODE;
NODE rootnode;
long start[2], root = NIL, freelist = NIL;
FILE *fptree;
/************ declaración de funciones ***************/
void search (int x);
int binsearch (int x, int *a, int n);
void found (long t, int i);
void notfound (int x);
void insert (int x);
int ins (int x, long t, int *y, long *u);
long getnode ();
void freenode (long t);
void readnode (long t, NODE *pnode);
void writenode (long t, NODE *pnode);
void rdstart ();
void wrstart ();
void error (char *str);
void borrar (int x);
int del (int x, long t);
/*****************************************************/
int main ()
{  int x;
  char ch, inpfilnam[30], treefilnam[30];
  FILE *fpinp;
 
  printf (&#34;Enter name of (binary) file for the B-tree; &#34;);
  scanf (&#34;%s&#34;, treefilnam);
  fptree = fopen (treefilnam, &#34;rb+&#34;);    /* rb+ and wb+  */
  if (fptree == NULL)            /* are system  */
  {  fptree = fopen (treefilnam, &#34;wb+&#34;);  /* dependent  */
    wrstart ();
  } else rdstart ();
 
  printf (&#34;Enter name of (ASCII) input file (or NONE) : &#34;);
  scanf (&#34;%s&#34;, inpfilnam);
  fpinp = fopen (inpfilnam, &#34;r&#34;);
  if (fpinp != NULL)
  {  while (fscanf (fpinp, &#34;%d&#34;, &x) &#62; 0) insert (x);
    fclose (fpinp);
  }
 
  while (1)
  {  printf (
    &#34;&#092;nDelete (D), Insert (I), Search (S) or Quit (Q): &#34;);
    do
    {  ch = getchar (); ch = toupper (ch);
    } while (ch != 'D' && ch != 'I' &&
          ch != 'S' && ch != 'Q');
    if (ch == 'Q') break;
    printf (&#34;Enter an integer: &#34;); scanf (&#34;%d&#34;, &x);
    switch (ch)
    {  case 'D': borrar (x); break;
      case 'I': insert (x); break;
      case 'S': search (x); break;
    }
  }
  wrstart ();
  fclose (fptree);
  return EXIT_SUCCESS;
}
 
void search (int x)
{  int i, j, *k, n;
  NODE nod;
  long t = root;
  printf (&#34;Trace:&#092;n&#34;);
  while (t != NIL)
  {  readnode (t, &nod);
    k = nod.key; n = nod.cnt;
    for (j = 0; j &#60; n; j++) printf (&#34;%d&#34;, k[j]);
    printf (&#34;&#092;n&#34;);
    i = binsearch (x, k, n);
    if (i &#60; n && x == k[i]) { found (t, i); return; }
    t = nod.ptr[i];
  }
  notfound (x);
}
 
int binsearch (int x, int *a, int n)
/* Search array a[0], a[1], ..., a[n-1] for x    */
/* Returned value:  0 if x &#60;= a[0],  n if x &#62; a[n-1],*/
/*          or r, where a[r-1] &#60; x &#60;= a[r]  */
{  int i, left, right;
  if (x &#60;= a[0]) return 0;
  if (x &#62; a[n-1]) return n;
  left = 0; right = n-1;
  while (right - left &#62; 1)
  {  i = right + left &#62;&#62; 1;
    if (x &#60;= a[i]) right = i; else left = i;
  }
  return right;
}
 
void found (long t, int i)
{  NODE nod;
  printf (&#34;Found in position %d &#34;, i);
  printf (&#34;of node with contents: &#34;);
  readnode (t, &nod);
  for (i = 0; i &#60; nod.cnt; i++) printf (&#34; %d&#34;, nod.key[i]);
  printf (&#34;&#092;n&#34;);
}
 
void notfound (int x)
{  printf (&#34;Item %d not found&#092;n&#34;, x);
}
 
void insert (int x)
/*  Driver function for node insertion, called only in the
  main program. Most of the work is delegated to 'ins'
*/
{  long tnew, u, getnode ();
  int xnew, code;
  code = ins (x, root, &xnew, &tnew);
  if (code == 2) printf (&#34;Duplicate key %d ignored&#092;n&#34;, x);
  if (code) return;
  u = getnode ();
  rootnode.cnt = 1; rootnode.key[0] = xnew;
  rootnode.ptr[0] = root; rootnode.ptr[1] = tnew;
  root = u;
  writenode (u, &rootnode);
}
 
int ins (int x, long t, int *y, long *u)
/*  Insert x in B-tree with root t. If not completely
  successful, the integer *y and the pointer *u
  remain to be inserted.
  Returned value:
    0 if insertion not completely successful.
    1 if insertion successful.
    2 if x is already present in B-tree.
*/
{  long tnew, getnode (), p_final, *p;
  int i, j, xnew, k_final, *n, *k, code;
  NODE nod, newnod;
  /*  Examine whether t is a pointer field in a leaf:
  */
  if (t == NIL) { *u = NIL; *y = x; return 0; }
 
  readnode (t, &nod);
        n = &nod.cnt; k = nod.key; p = nod.ptr;
 
  /* Select pointer p[i] and try to insert x in
    the subtree of which p[i] is the root;
  */
  i = binsearch (x, k, *n);
  if (i &#60; *n && x == k[i]) return 2;  /* Duplicate key */
  code = ins (x, p[i], &xnew, &tnew);
  if (code) return code;
 
  /* Insertion in subtree did not completely succed;
    try to insert xnew and tnew in the current node:
  */
  if (*n &#60; MM)
  {  i = binsearch (xnew, k, *n);
    for (j = *n; j &#62; i; j--)
    {  k[j] = k[j-1]; p[j+1] = p[j];
    }
    k[i] = xnew; p[i+1] = tnew; ++*n;
    writenode (t, &nod); return 1;
  }
 
  /* The current node was already full, so split it. Pass
    item k[M] in the middle of the augmented sequence
    back through parameter y, so that it can move
    upward in the tree. Also, pass a pointer to the newly
    created node back through u. Return 0, to report
    that insertion was not completed:
  */
  if (i == MM) { k_final = xnew; p_final = tnew; } else
  {  k_final = k[MM-1]; p_final = p[MM];
    for (j = MM-1; j &#62; i; j--)
    {  k[j] = k[j-1]; p[j+1] = p[j];
    }
    k[i] = xnew; p[i+1] = tnew;
  }
  *y = k[M]; *n = M;
 
  *u = getnode (); newnod.cnt = M;
  for (j = 0; j &#60; M-1; j++)
  {  newnod.key[j] = k[j+M+1]; newnod.ptr[j] = p[j+M+1];
  }
  newnod.ptr[M-1] = p[MM]; newnod.key[M-1] = k_final;
  newnod.ptr[M] = p_final;
  writenode (t, &nod); writenode (*u, &newnod); return 0;
}
 
long getnode ()
{  long t;
  NODE nod;
  if (freelist == NIL)
  {  if (fseek (fptree, 0L, 2)) error (&#34;fseek in getnode&#34;);
    t = ftell (fptree);
    writenode (t, &nod);  /* Reserve space on disk */
  } else
  {  t = freelist;
    readnode (t, &nod);  /* To update freelist */
    freelist = nod.ptr[0];
  }
  return t;
}
 
void freenode (long t)
{  NODE nod;
  readnode (t, &nod);
  nod.ptr[0] = freelist;
  freelist = t;
  writenode (t, &nod);
}
 
void readnode (long t, NODE *pnode)
{  if (t == root) { *pnode = rootnode; return; }
  if (fseek (fptree, t, 0)) error (&#34;fseek in readnode&#34;);
  if (fread (pnode, sizeof (NODE), 1, fptree) == 0)
    error (&#34;fread in readnode&#34;);
}
 
void writenode (long t, NODE *pnode)
{  if (t == root) rootnode = *pnode;
  if (fseek (fptree, t, 0)) error (&#34;fseek in writenode&#34;);
  if (fwrite (pnode, sizeof (NODE), 1, fptree) == 0)
    error (&#34;fwrite in writenode&#34;);
}
 
void rdstart ()
{  if (fseek (fptree, 0L, 0)) error (&#34;fseek in rdstart&#34;);
  if (fread (start, sizeof (long), 2, fptree) == 0)
    error (&#34;fread in rdstart&#34;);
  readnode (start[0], &rootnode);
  root = start[0]; freelist = start[1];
}
 
void wrstart ()
{  start[0] = root; start[1] = freelist;
  if (fseek (fptree, 0L, 0)) error (&#34;fseek in wrstart&#34;);
  if (fwrite (start, sizeof (long), 2, fptree) == 0)
    error (&#34;fwrite in wrstart&#34;);
  if (root != NIL) writenode (root, &rootnode);
}
 
void error (char *str)
{  printf (&#34;&#092;nError: %s&#092;n&#34;, str);
  exit (EXIT_FAILURE);
}
 
void borrar (int x)
/* Driver function for node deletion called only in the
  main program. Most of the work is delegated to &#34;del&#34;.
*/
{  int code;
  long newroot;
  code = del (x, root);
  if (code == 2) printf (&#34;%d not found&#092;n&#34;, x);
  if (code) return;
  /* 0 = underflow; 1 = success; 2 = key not found   */
  /* If underflow, decrease the height of the three: */
  newroot = rootnode.ptr[0]; freenode (root);
  if (newroot != NIL) readnode (newroot, &rootnode);
  root = newroot;
}
 
int del (int x, long t)
/* Delete item x in B-tree with root t.
   Returned value:
   0 = underflow, 1 = success, 2 = not found
*/
{  int i, j, *k, *n, *item, code,
    *nleft, *nright, *lkey, *rkey, borrowleft, nq, *addr;
  long *p, left, right, *lptr, *rptr, q, q1;
  NODE nod, nod1, nod2;
  if (t == NIL) return 2;
  readnode (t, &nod);
  n = &nod.cnt; k = nod.key; p = nod.ptr;
  i = binsearch (x, k, *n);
  if (p[0] == NIL)  /* *t is a leaf */
  {  if (i == *n || x &#60; k[i]) return 2;
    /* x is now equal to k[i], located in a leaf: */
    for (j = i+1; j &#60; *n; j++)
    {  k[j-1] = k[j]; p[j] = p[j+1];
    }
    --*n;
    writenode (t, &nod);
    return *n &#62;= (t == root ? 1 : M);
  }
  /* *t is an interior node (not a leaf): */
  item = k+i; left = p[i]; readnode (left, &nod1);
  nleft = &nod1.cnt;
  if (i &#60; *n && x == *item)
  { /* x found in interior node.             */
    /* Go to left child *p[i] and then follow a path   */
    /* all the way to a leaf, using rightmost branches */
    q = p[i]; readnode (q, &nod1); nq = nod1.cnt;
    while (q1 = nod1.ptr[nq], q1 != NIL)
    {  q = q1; readnode (q, &nod1); nq = nod1.cnt;
    }
    /* Exchange k[i] with the rightmost item in
      that leaf:
    */
    addr = nod1.key + nq - 1;
    *item = *addr; *addr = x;
    writenode (t, &nod); writenode (q, &nod1);
  }
  /* Delete x in subtree with root p[i] */
  code = del (x, left);
  if (code) return code;
  /* Underflow: borrow, and, if necessary, merge */
  borrowleft = i == *n;
  if (borrowleft)  /* p[i] is rightmost pointer in *p */
  {  item = k+i-1; left = p[i-1]; right = p[i];
    readnode (left, &nod1);
    nleft = &nod1.cnt;
  } else right = p[i+1];
  readnode (left, &nod1);
  readnode (right, &nod2);
  nright = &nod2.cnt;
  lkey = nod1.key; rkey = nod2.key;
  lptr = nod1.ptr; rptr = nod2.ptr;
  if (borrowleft)  /* This is an exception */
  {  rptr[*nright + 1] = rptr[*nright];
    for (j = *nright; j &#62; 0; j--)
    {  rkey[j] = rkey[j-1];
      rptr[j] = rptr[j-1];
    }
    ++*nright;
    rkey[0] = *item; rptr[0] = lptr[*nleft];
    *item = lkey[*nleft - 1];
    if (--*nleft &#62;= M)
    {  writenode (t, &nod); writenode (left, &nod1);
      writenode (right, &nod2);
      return 1;
    }
  } else
  if (*nright &#62; M)  /* Borrow from right sibling: */
  {  lkey[M-1] = *item; lptr[M] = rptr[0]; *item = rkey[0];
    ++*nleft; --*nright;
    for (j = 0; j &#60; *nright; j++)
    {  rptr[j] = rptr[j+1]; rkey[j] = rkey[j+1];
    }
    rptr[*nright] = rptr[*nright + 1];
    writenode (t, &nod); writenode (left, &nod1);
    writenode (right, &nod2);
    return 1;
  }
  /* Merge */
  lkey[M-1] = *item; lptr[M] = rptr[0];
  for (j = 0; j &#60; M; j++)
  {  lkey[M+j] = rkey[j]; lptr[M+j+1] = rptr[j+1];
  }
  *nleft = MM;
  freenode (right);
  for (j = i+1; j &#60; *n; j++) { k[j-1] = k[j]; p[j] = p[j+1]; }
  --*n;
  writenode (t, &nod);
  writenode (left, &nod1);
  return *n &#60;= (t == root ? 1 : M);
}
 
 

maikmr

Tiene razon el compilador a usar es un detalle muy importante, y a mi se me habia olvidado mencionarlo. para este trabajo se me pidio usar el compilador de GNU, pues dicho se a de paso estoy trabajando sobre GNU/Linux y cuando compile el codigo y que medio 26 errores lo intente compilar en C++ Builder.

gracias!! una ves mas!

SoloCodigo

Autor Tema: Escr Y Leer Una Clase En Un File Aleatorio En C++ (Leído 7057 veces)

maikmr

Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

pitukilloloco

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++

maikmr

Re: Escr Y Leer Una Clase En Un File Aleatorio En C++