• Lunes 4 de Julio de 2022, 11:06

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - Luciano9

Páginas: [1]
1
C/C++ / Problema en modo grafico
« en: Sábado 19 de Septiembre de 2009, 01:59 »
Hola gente, escribo porque tengo el siguiente problema.
En donde estudio, estamos empezando con el modo graphico. Utilizamos el viejo y conocido IDE Borland Turbo C++ (el de DOS).
Mi programa hace una simple tabla, en algunas PCS la puedo visualizar perfectamente, en cambio, en mis 3 pcs de mi casa, no puedo porque me arroja un error del NTVDM.
Busqué mil y un soluciones, y ninguna funcionó.. Probé usar DOSBOX y tampoco puedo ver los graficos... El programa compila perfectamente, cuando lo ejecuto se cierra el turbo o me tira el error de NTVDM 16 bits subsystem algo asi.

Alguien sabe a qué se debe?, tiene que ver con windows xp sp3?...

(Intente cambiar de IDE pero tengo problema en la compatibilidad de algunas librerias... por ejemplo uso stdlib y me tira errores en la libreria así que no tengo idea como hacer...)


espero que alguien me pueda ayudar!

2
C/C++ / Parametros genericos....
« en: Viernes 8 de Mayo de 2009, 21:04 »
&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
  1.  
  2. #ifndef __ARCH_H
  3. #define __ARCH_H
  4. //Librerias
  5. #include <stdio.h>
  6. #include "TDARCH.h"
  7.  
  8. //Prototipos
  9. void AbrirArchivo (FILE * &Arch, bool &bPudo, char * dir, char tipo); //Procedimiento de apertura de archivos de Entrada y de Salida
  10. void LeerArchivo (FILE * &Arch, ty_TDArch &Reg, bool &bFin);  //Procedimiento de lectura de archivo
  11. void GrabarArchivo (FILE * &Arch, ty_TDArch &Reg);  //Procedimiento de guardado de archivo
  12. void CerrarArchivo (FILE * &Arch);  //Procedimiento de cerrado de archivo
  13.  
  14.  
  15. #endif /*__ARCH_H*/
  16.  
  17.  

ARCH.cpp
Código: Text
  1.  
  2. //Librerias
  3. #include "ARCH.h"
  4. #include <iostream.h>
  5.  
  6. ////////////////////////////////////////////////////////////////////////////////////////////
  7. //Rutina LeerArchivo (FILE * &Arch, ESTRUCT &estructura, bool &bfin)
  8. ////////////////////////////////////////////////////////////////////////////////////////////
  9. void LeerArchivo (FILE * &Arch, ty_TDArch &Reg, bool &bFin)
  10.                                                         //Rutina para leer un Archivo
  11.  
  12. {
  13.  
  14.     if (!(feof(Arch))) {                                //Si no es fin de archivo
  15.        fread (&Reg, sizeof(ty_TDArch),1,Arch);     //Leo el archivo
  16.          bFin = FALSE;                                  //No termino la lectura, porque lo lei
  17.     } else {                                            //Caso contrario, Termino la lectura
  18.          bFin = TRUE;
  19.     }
  20. }
  21. //Fin de Rutina -  LeerArchivo (FILE * &Arch, ESTRUCT &estructura, bool &bfin) -
  22.  
  23.  
  24.  
  25. ////////////////////////////////////////////////////////////////////////////////////////////
  26. //Rutina - AbrirArchivo (FILE*Arch,bool&bPudo,char*dir,char tipo) -
  27. ////////////////////////////////////////////////////////////////////////////////////////////
  28. void AbrirArchivo (FILE * , bool &bPudo, char * dir, char tipo)
  29.                                         //Rutina para abrir un archivo de Entrada o de Salida
  30. {
  31.     if (tipo == 'E')  {                 //Si el tipo de archivo es de Entrada
  32.  
  33.         Arch=fopen (dir,"rt");          //Abro el archivo de entrada
  34.  
  35.             if (Arch == NULL) {         //Si no encuentra el archivo
  36.                 cout << "No se pudo abrir el archivo de Entradan";
  37.                 bPudo=FALSE;            //bPudo Abrirlo es FALSO
  38.             }else{
  39.                 bPudo=TRUE;             //Caso contrario bPudo Abrirlo es VERDADERO
  40.             }
  41.  
  42.     } else {                            //Caso contrario el archivo es de Salida
  43.  
  44.         Arch=fopen (dir,"a+");          //Abro el archivo de salida
  45.  
  46.  
  47.             if (Arch == NULL) {         //Si no encuentra el archivo
  48.                 cout << "No se pudo abrir el archivo de Salidan";
  49.                 bPudo=FALSE;            //bPudo Abrirlo es FALSO
  50.             }else{
  51.                 bPudo=TRUE;             //Caso contrario bPudo Abrirlo es                  //VERDADERO
  52.  
  53.             }
  54.  
  55.     }
  56. }
  57. //Fin de Rutina - AbrirArchivo (FILE*Arch,bool&bPudo,char*dir,char tipo) -
  58.  
  59.  
  60. ////////////////////////////////////////////////////////////////////////////////////////////
  61. //Rutina - GrabarArchivo1 (FILE*Arch,ESTRUCT &estructura) -
  62. ////////////////////////////////////////////////////////////////////////////////////////////
  63. void GrabarArchivo1 (FILE * &Arch, ty_TDArch &Reg)
  64. {                                                       //Rutina para grabar un archivo
  65.     fwrite (&Reg, sizeof(ty_TDArch),1,Arch);       //Graba el archivo
  66. }
  67. //Fin de Rutina - GrabarArchivo (FILE*Arch,ESTRUCT &estructura) -
  68.  
  69.  
  70. ////////////////////////////////////////////////////////////////////////////////////////////
  71. //Rutina - CerrarArchivo (FILE * &Arch)
  72. ////////////////////////////////////////////////////////////////////////////////////////////
  73. void CerrarArchivo (FILE * &Arch)
  74. {                                                       //Rutina para cerrar un archivo
  75.     fclose(Arch);                                       //Cierra el archivo
  76. }
  77. //Fin de Rutina - CerrarArchivo (FILE * &Arch)
  78.  
  79.  
  80.  


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
  1. #include "STRCTP3.h"
  2.  
  3. #define FALSE 0
  4. #define TRUE (1 == 1)
  5.  
  6. typedef int bool;
  7.  
  8.  

Ahora bien, tengo 2 registros que contienen lo siguiente:
STRCTP3.H
Código: Text
  1. typedef struct ty_RegOrig{
  2.     ty_VecV VecV;
  3.     ty_VecVB VecVB;
  4. }; //estructura para registro de archivo vectores originales
  5.  
  6. typedef struct ty_RegResult{
  7.     ty_VecResB VecResBOrd;
  8.     ty_VecResB VecResBDes;
  9.     ty_VecResB VecResBBin;
  10.     ty_VecReO VecResOrd;
  11. }; //estructura para registro de archivo vectores de resultados
  12.  
  13.  

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.

Páginas: [1]