SoloCodigo

Espero Que la Siguiente Informacion Sea de Utilidad




/*****
Prototipo de la Funcion fwrite:
******************************/
size_t fwrite(Buffer, Tam_Elemento, Nro_Elementos, Punt_File)
char *Buffer;             /* Puntero a la Información Que Se Va A Guardar */
size_t Tam_Elemento;               /* Nro de Bytes Por Elemento a Guardar */
Nro_Elementos;                              /* Nro de Elementos a Guardar */
FILE *Punt_File;/* Puntero al Archivo Donde Se Va A Grabar la Informacion */

/***
Valor de Retorno
****************

El Numero de Elementos Efectivamente Grabados.

Este Nro Debe Ser Igual a Nro_Elementos, En Caso Contrario Indica Que
Se ha Producido Un Error de Escritura y  Retorna  el Nro de Elementos
Efectivamente Guardado Entes de Producirse el Error. En cuyo Caso  la
instrucción ferror (FILE *Punt_File) Retornara True Para Confirmar La
Existencia de Un Error.
**********************/

/***
Verificar Si La Escritura Tuvo Exito
Si No Grabo El Nro de Elementos Indicado Se Produjo un Error
***********************************************************/

if(fwrite(Buffer, Tam_Elemento, Nro_Elementos, Punt_File) != Nro_Elementos)
 {
  perror(Error de Escritura Ejenplo.c Linea xxx:);
  exit(-1);
  }
/***
else printf ("La Escritura Fue Exitosa");
****************************************/

/*****
Prototipo de la Funcion fread:
******************************/
size_t fread(Buffer, Tam_Elemento, Nro_Elementos, Punt_File)
char *Buffer;             /* Puntero Donde se Va a Guardar la Información */
size_t Tam_Elemento;                  /* Nro de Bytes Por Elemento a Leer */
Nro_Elementos;                                 /* Nro de Elementos a Leer */
FILE *Punt_File;  /* Puntero al Archivo Donde Se Va A Leer la Informacion */

/***
Valor de Retorno
****************

El Numero de Elementos Efectivamente Leidos.

El Nro de Elementos Leidos Debe Ser Igual a Nro_Elementos. En Caso Contrario
Indica Que Se llego al Fin Del Archivo o Que Se Produjo Un Error
***************************************************************************/

/***
Verificar Si La Lectura Tuvo Exito
Si No Leyo El Nro de Elementos Indicado Se Llego a Fin de Archivo
o Se Produjo un Error en la Lectura
***********************************************************/

if(fread(Buffer, Tam_Elemento, Nro_Elementos, Punt_File) != Nro_Elementos)
 {
  if(!ferror(Punt_File)) printf("Se Llego a Fin de Archivo");
  else
   {
    perror(Error de Lectura Ejemplo.c Linea xxx:);
    exit(-1);
    }
  }
/***
printf ("La Lectura Fue Exitosa");
*********************************/
/*****
Resto del Codigo
...
...

/***
Si Se Esta Dentro de Un Bucle Verificar Que Se Llego  a Fin de Archivo
Por Ejemplo:
*********************************************************************/
/***
Si No Hay Fin de Archivo Continue
********************************/
if(!feof(Punt_File)) continue;

/***
Si Encuentra Fin de Archivo Rompa
********************************/

if(feof(Punt_File)) break;
*********************/

/***
Cerrar Los Archivos Abiertos Antes de Terminar El Programa
*********************************************************/
fclose(Punt_File);


/**********************************
Otros Elementos a Considerar en el Sistema de Entrada/Salida
***********************************************************/
/***
Despues de Toda Accion de Lectura o Escritura fwrite o fread la
POSICION ACTUAL del Punt_File Apunta a la Posicion Nro_Elementos
Por Tam_Elementos Leidos o Escritos.
Ejemplo:
**************************************************************/

/***
Accion de Escritura
********************************************************/
strcpy(Buffer,"Esta Es Una Escritura de Prueba");
Nro_Elementos = strlen(Buffer);
if(fwrite(Buffer, sizeof(char),Nro_Elementos, Punt_File) != Nro_Elementos)
 {
  perror(Error de Escritura Ejemplo.c Linea xxx:);
  exit(-1);
  }
else printf ("Se Grabo [%s] Exitosamenten",Buffer);


/***
Accion de Lectura de Lo que Se Acaba de Grabar
*********************************************/
/***
Prototipo de Funcion fseek:
***************************
int fseek(Punt_File, Nro_Bytes, Origen)
FILE *Punt_File;
long Nro_Bytes;    /* Nro de Bytes a Moverse "Valor negativo o Positivo" */
int Origen;        /* A Partir de Donde Se Va a Mover:
                      SEEK_SET Desde el Origen del Archivo,
                      SEEK_CUR A Partir de la Posicion Actual
                      SEEK_END A Partir del Fin del Archivo              */
**************************************************************************/

/***
Se Posiciona el Archivo En la Posicion Inicial Donde Se Grabo.
Moviendose desde la Posición Actual Hacia Atras Un Numero de Bytes
Igual Al Tamaño de Cada Elemento Por el Nro. de Elementos Grabados
*****************************************************************/
fseek(Punt_File, -sizeof(char)*Nro_Elementos, SEEK_CUR);
/***
Se Inicializa el Buffer
**********************/
Buffer[0] = 0x00; /* Se coloca "" en el Primer Elemento del Buffer */
/***
Se lee el Archivo
****************/
if(fread(Buffer, Tam_Elemento, Nro_Elementos, Punt_File) != Nro_Elementos)
 {
  if(!ferror(Punt_File)) printf("Se Llego a Fin de Archivon");
  else
   {
    perror(Error de Lectura Ejemplo.c Linea xxx:);
    exit(-1);
    }
  }
printf ("Buffer Leyo [%s] Exitosamenten",Buffer);

/***
Si Se Desea Ir Al Comienzo del Archivo
Se Puede Utilizar la Instruccion:

void rewind(FILE *Punt_File)
*************************************/

Creo que el Problema esta en la Forma Como Calculas el El Tamaño de la Structura mao con la instruccion sizeof

typedef struct
 {
  char *nombre;
  char *direccion;
  int edad;
  } mao;


void introdatos(mao *p,int datos);
void borradatos(mao *p,int datos);
void modificadatos(mao *p,int datos);
void listadatos(mao *p,int datos);
void ventana();
void menu();


void main()
{
ventana();
mao *p;
int datos=0,opc;
/***
La Structura mao Tiene dos Elementos
que Son Punteros tipo Char, Esta Instruccion no Calcula el espacio de memoria necesario
para Guardar un elemento en la structura
***********************************/
p=(mao *)malloc (sizeof(mao));
/******
Sin Que este entrando en un anlisis Profundo del Problema Te Sugiero Que Daclares
si requieres Memoria Dinamica
************************************/
p = (mao *)malloc(sizeof (mao)+ strlen(nombre)+ strlen(direccion));
/****************
Pero si ya Conoces el Tamaño de la Structura
Es mejor que Trabajes Sobre un Buffer con
dimensiones ya determinadas
*******************************************/
char Len_Int = sizeof(int); /*Portabilidad */
char Buf_Mao[Len_Int+47];/* 30 char x Nombre + 15 char x direccion.
/***
Modeas el Puntero
****************/
p = (mao *)Buf_Mao;

...
/*******
Creo Que Buena Parte del Problema Lo Tienes
Aqui. al Final Si usas  malloc, debes liberar la memoria co la instruccion free(mao p)
******************************************/


-----------------------------
Solo se Que no se NADA

La Manipulacion de Las Variables en C

Parten de Su Declaración:

Si Declaras Una Variable Tipo char

char Variable_Char;

el Compilador Reservo un Byte de memoria Para la Variable_Char.

Si Declaras UN PUNTERO tipo char

char *Punt_Char;

El Compilador No Reserva Memoria, sino identifica el lugar donde puedes guardar la direccion de cualquier Variable o Arreglo del
tipo char.

Si Declaramos un Arreglo del

char Arreglo_Char[256];

El Compilador Reserva Memoria Para 256 caracteres, Su Puntero es el Nombre del arreglo "Arreglo_Char" y sus elementos estan identificado desde el Primero Arreglo_Char[0]hasta el Ultimo Arreglo_Char[255].

COMO SE MANIPULAN Y POR QUE?

Punt_Char = &Variable_Char;

Si Variable_Char = "A";

Punt_Char Contine la Direccion de la Variable_Char

*Punt_Char contiene el Valor ASCCI de la "A";

Cuando Pasas Una Variable de los tipos Basicos del "C" char,short,int,long,double
Como Argumento a Una Funcion, La Funcion Recibe el Valor Que Contenga al Inicio, y
Cualquier Modificacion que se efectue dentro del cuerpo de la funcion No tedra ningun efecto Sobre la Variable en el Programa que la Llamo. Manteniendo el Valor que Tenia al al Momento de llamar la Funcion.

Si Pasas el Puntero Si Se Puede Modificar el valor de la Variable Dentro de la Funcion.

Si
Punt_Char = Arreglo_Char;

Punt_Char Toma el Valor del Puntero al Primer elemento del Arreglo. (&Arreglo_Char[0])

Y la Unica Forma de Pasar de Pasar Una Variable Compleja Como Parametro a Una Funcion Es Mediante Su Puntero.

Funcion_Char(Arreglo_Char);
o Funcion_Char(Punt_Char);

Espero Te Sirva la Informacion

Para Tomar Una Decision de si Usar Un
Puntero o la Estructura, Debes Tomar en
Cunta lo Siguiente:

Si Declaras Un Puntero a Una Structura
struct personas *Punt_Per, Personas;

Punt_Per Es Un Puntero a Una structura tipo
Personas Pero No Apunta a Ninguna Direccion
Definida.

Por Eso La Primera Instruccion Debe Ser:
Punt_Per = NULL;

Mientras Que la Variable Personas es una structura del Tipo personas y Su Diresccion
es &Personas.

De Tal Manera Que Si:

Punt_Per = &Personas;

Entonces Personas ed la Estructura
y Punt_Per es Su Direccion.

Cual de las Dos Usar;

Para Una Llamada de Funcion Con Argumento
La structura Persona, Solamente Puedes
Pasar Su Direccion

Funcio_Per(&Personas);
o
Funcion_Per(Punt_Per);

y Dentro de la Funcion Tienes Que usar el
Puntero,

En el Ejemplo Que Mencionas Tienes UN Error Por que el Puntero a la Structura No esta Inicializado.

En Cuanto A cuando Usar La Structura y Cuando Usar el Puntero:

Puedes Dirigirte Directamente a la structura
Cuando:

La Has Declarado Como Una Variable General;
Cuando la has Declarado Como una Variable
Local Dentro de la Función donde la Vas a
Utilizar.

Tienes Que Utilizar el Puntero Si Has Pasado
la Structura Como Argumento de Una Funcion.
Puesto Que la Una Forma de Pasar Un Arreglo,
Union o structura Como Parametro de una Funcion es Mediante Su  Puntero.

Fun_Per(struc personas *Punt_Per)
 {
  /***
  Aqui es Necesario Referirse al Puntero
  Para Accesar un Elemento de la structura
  **********************/
  }

[Modificado el 3/5/02 por bench]

He Desarrollado LIbrerias Para el Manejo de
de Bases de Datos Relacionales Orientadas a Grandes Bases de Datos. Su Presentacion es en modo texto Basadas en Ncurses, Muy Parecidas a una Aplicacion en Clipper, Por lo Tanto Tengo buen conocimiento del Manejo de structuras, arboles binarios, y me inter4esa el manejo del modo grafico a bajo nivel Por lo tanto mandame informacion Par ver en qu puedo colaborar.,

[Modificado el 2/22/02 por bench]