Pasar por parametros

[Luciano9]

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*/

ARCH.cpp

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.

[Eternal Idol]

Código:

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:

FILE *Arch; //no ponemos aca como abrimos el archivo, no interesa
ty_RegResult var; //lo mismo para como inicializamos la estructura
GrabarArchivo1(Arch, (void*)var, sizeof(ty_RegResult));

[Luciano9]

gracias, justo lo que necesitaba.

[Eternal Idol]

De nadas