Programación General > C/C++
Parametros genericos....
Luciano9:
&ArchHola, antes que nada me presento. Me llamo Luciano, estudio Analisis de Sistemas y soy nuevo en el foro.
Tengo una duda sobre lo siguiente:
Estoy haciendo 1 proyecto que maneja archivos.
Tengo varios cpps con sus respectivos .h de los cuales uno se llama "ARCH.CPP" y tiene su "ARCH.H".
Estos tienen las funciones básicas de archivos (grabar, leer, abrir, cerrar) pero de forma más genérica: "AbrirArchivo(parametros), en lugar de fopen = (parametros)".
El proyecto necesita grabar 2 archivos, cada uno de una estructura diferente.
Lo que necesito es saber como hacer esta libreria arch.h genérica para aceptar cualquiera de las dos estructuras que le mande por parámetro.
(No puedo usar un #define TIPODATOARCHIVO ty_miregistro porque tengo 2 registros...)
Tampoco estoy familiarizado con el uso de punteros ni objetos.
ARCH.h
--- Código: Text --- #ifndef __ARCH_H#define __ARCH_H//Librerias#include <stdio.h>#include "TDARCH.h" //Prototiposvoid AbrirArchivo (FILE * &Arch, bool &bPudo, char * dir, char tipo); //Procedimiento de apertura de archivos de Entrada y de Salidavoid LeerArchivo (FILE * &Arch, ty_TDArch &Reg, bool &bFin); //Procedimiento de lectura de archivovoid GrabarArchivo (FILE * &Arch, ty_TDArch &Reg); //Procedimiento de guardado de archivovoid CerrarArchivo (FILE * &Arch); //Procedimiento de cerrado de archivo #endif /*__ARCH_H*/
ARCH.cpp
--- Código: Text --- //Librerias#include "ARCH.h"#include <iostream.h> //////////////////////////////////////////////////////////////////////////////////////////////Rutina LeerArchivo (FILE * &Arch, ESTRUCT &estructura, bool &bfin)////////////////////////////////////////////////////////////////////////////////////////////void LeerArchivo (FILE * &Arch, ty_TDArch &Reg, bool &bFin) //Rutina para leer un Archivo { if (!(feof(Arch))) { //Si no es fin de archivo fread (&Reg, sizeof(ty_TDArch),1,Arch); //Leo el archivo bFin = FALSE; //No termino la lectura, porque lo lei } else { //Caso contrario, Termino la lectura bFin = TRUE; }}//Fin de Rutina - LeerArchivo (FILE * &Arch, ESTRUCT &estructura, bool &bfin) - //////////////////////////////////////////////////////////////////////////////////////////////Rutina - AbrirArchivo (FILE*Arch,bool&bPudo,char*dir,char tipo) -////////////////////////////////////////////////////////////////////////////////////////////void AbrirArchivo (FILE * , bool &bPudo, char * dir, char tipo) //Rutina para abrir un archivo de Entrada o de Salida{ if (tipo == 'E') { //Si el tipo de archivo es de Entrada Arch=fopen (dir,"rt"); //Abro el archivo de entrada if (Arch == NULL) { //Si no encuentra el archivo cout << "No se pudo abrir el archivo de Entradan"; bPudo=FALSE; //bPudo Abrirlo es FALSO }else{ bPudo=TRUE; //Caso contrario bPudo Abrirlo es VERDADERO } } else { //Caso contrario el archivo es de Salida Arch=fopen (dir,"a+"); //Abro el archivo de salida if (Arch == NULL) { //Si no encuentra el archivo cout << "No se pudo abrir el archivo de Salidan"; bPudo=FALSE; //bPudo Abrirlo es FALSO }else{ bPudo=TRUE; //Caso contrario bPudo Abrirlo es //VERDADERO } }}//Fin de Rutina - AbrirArchivo (FILE*Arch,bool&bPudo,char*dir,char tipo) - //////////////////////////////////////////////////////////////////////////////////////////////Rutina - GrabarArchivo1 (FILE*Arch,ESTRUCT &estructura) -////////////////////////////////////////////////////////////////////////////////////////////void GrabarArchivo1 (FILE * &Arch, ty_TDArch &Reg){ //Rutina para grabar un archivo fwrite (&Reg, sizeof(ty_TDArch),1,Arch); //Graba el archivo}//Fin de Rutina - GrabarArchivo (FILE*Arch,ESTRUCT &estructura) - //////////////////////////////////////////////////////////////////////////////////////////////Rutina - CerrarArchivo (FILE * &Arch)////////////////////////////////////////////////////////////////////////////////////////////void CerrarArchivo (FILE * &Arch){ //Rutina para cerrar un archivo fclose(Arch); //Cierra el archivo}//Fin de Rutina - CerrarArchivo (FILE * &Arch)
La idea de esta libreria propia, es que esté encapsulada. Para acceder a los datos de ella, pense hacer un TDARCH.h que la maneje, de esta forma no tendria que romper el encapsulamiento cada vez que quiera cambiar algo.
TDARCH.h
--- Código: Text ---#include "STRCTP3.h" #define FALSE 0#define TRUE (1 == 1) typedef int bool;
Ahora bien, tengo 2 registros que contienen lo siguiente:
STRCTP3.H
--- Código: Text ---typedef struct ty_RegOrig{ ty_VecV VecV; ty_VecVB VecVB;}; //estructura para registro de archivo vectores originales typedef struct ty_RegResult{ ty_VecResB VecResBOrd; ty_VecResB VecResBDes; ty_VecResB VecResBBin; ty_VecReO VecResOrd;}; //estructura para registro de archivo vectores de resultados
Estos 2 registros tengo que guardarlos en 2 archivos diferentes utilizando el mismo procedimiento de guardar. Y ahí está el problema, los tipos de dato son diferentes.
Si alguien me puede explicar como hacer para pasarle directamente una posicion de memoria para que lea "X" tamaño, indiferentemente del tipo, le agradezco mucho.
Espero que se entienda, me cuesta 1 poco explicar esto por acá.
Muchas gracias de antemano.
Saludos.
Eternal Idol:
¿¿Queres leer/escribir buffers??
Pasa a la funcion que graba un char * (haces casting para pasarle lo que sea) y el tamaño total (de la estructura que queres grabar). Es lo que hacen fread/fwrite al fin y al cabo B)
Luciano9:
Te agradezco la respuesta, pero soy bastante novato en el tema...
Lo que entendí hasta ahora es esto:
Yo tendría que pasarle a mi rutina "genérica" de grabar, un puntero a la posicion de memoria donde empiece mi registro... supongo que será un void * reg... algo asi.
Despues tengo que pasarle el sizeof(miregistro), la cantidad de veces q graba y el archivo con la estructura FILE.
en stdio.h está el encabezado del fwrite como
--- Código: Text ---unsigned fwrite(const void *__ptr, size_t __size_t, size_t __size_n, FILE * __stream);
Esto es totalmente generico, porque siendo REG o REGASDAD o REGISTROASD o lo que le pase, va a funcionar.
Lo que quiero saber es como implementarlo en mi rutina (que en definitiva es la misma pero con mis propios nombres)
gracias.
Eternal Idol:
--- Código: Text --- void GrabarArchivo1 (FILE *Arch, void *buffer, unsigned int bufferLen){ fwrite (buffer , 1, bufferLen , Arch);}
Entonces si queres grabar esta estructura ty_RegResult por ejemplo haces asi:
--- Código: Text --- FILE *Arch; //no ponemos aca como abrimos el archivo, no interesaty_RegResult var; //lo mismo para como inicializamos la estructuraGrabarArchivo1(Arch, (void*)var, sizeof(ty_RegResult));
Luciano9:
gracias, era eso lo q necesitaba...
Navegación
[#] Página Siguiente
Ir a la versión completa