Hola, 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:
#ifndef __ARCH_H
#define __ARCH_H
//Librerias
#include <stdio.h>
#include "TDARCH.h"
//Prototipos
void AbrirArchivo (FILE * &Arch, bool &bPudo, char * dir, char tipo); //Procedimiento de apertura de archivos de Entrada y de Salida
void LeerArchivo (FILE * &Arch, ty_TDArch &Reg, bool &bFin); //Procedimiento de lectura de archivo
void GrabarArchivo (FILE * &Arch, ty_TDArch &Reg); //Procedimiento de guardado de archivo
void CerrarArchivo (FILE * &Arch); //Procedimiento de cerrado de archivo
#endif /*__ARCH_H*/
Código:
//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 * &Arch, 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 Entrada\n";
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 Salida\n";
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:
#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:
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.