| Ver tema anterior :: Ver siguiente tema | | Autor | Mensaje |
|---|
EgLoMeR
Registrado: 10 Sep 2006
Mensajes: 15
|  Publicado: 20/09/2007 4:22 pm | | | Título: ayuda binaria |
| Hola a todos:
Estoy creando un programa para pasar lecturas binarias de archivos a decimales, a ver si podéis ayudarme.
Lo que busco exactamente es una función a la que, pasándole un FILE* sea capaz de decirme los 0 y 1 que componen dicho FILE* pero al revés, es decir, que primero me muestre el último byte del archivo y por último, el primero.
He probado con esto:
| Código: | FILE *archivo, *salida;
char *datos // datos del archivo
long tamano = 0; // tamaño del archivo
// Abre archivo de entrada como solo lectura en modo binario
if ((archivo = fopen(argv[2],"rb")) == NULL){
printf ("Error al abrir archivo de entrada %s", argv[2]);
return 0;
}
// Nos ponemos al final del archivo una vez abierto
fseek (archivo, 0, SEEK_END);
// Sacamos el tamaño del archivo en bytes
tamano = ftell (archivo);
// Volvemos al inicio del archivo
rewind (archivo);
// Comprobamos que el archivo no esté vacío
if (tamano <= 0){
fclose (archivo); // Cerramos archivo
printf ("El archivo %s está vacío", argv[2]);
return 0;
}
// Asignación de memoria dinámica
datos = new char[(tamano + 1)];
// Lectura del archivo y cierre
fread (datos, 1, tamano, archivo);
fclose (archivo);
// Pasamos la cadena datos a decimal
decimal (tamano, datos, conta);
|
y esta ultima funcion usa un bucle for para leer al revés desde la cadena datos, pero no me va. alguna ayuda?
SO WinXP SP2
compilador Visual C++ 6 |
| | Volver arriba | |  | DCelso
Registrado: 28 Abr 2004
Mensajes: 112
| | Publicado: 20/09/2007 5:13 pm | | | Título: |
| Es muy dificil puesto que un FILE siempre es una lectura secuencial descendente. Se podría hacer dos cosas:
La primera seria situarse al final del fichero con fseek( fichero, -1L, SEEK_END );
luego hacer un bucle que:
* lea y muestre un byte c=fgetc(archivo); printf("%c".c);
* y luego se situe dos posiciones a atrás, la que leyó y mostró y la que leerá y mostrara en la siguiente iteración fseek( fichero, -2L, SEEK_CUR);
hasta llevar a estár en la primera posicion ftell( fichero )==0
(Un poco cutre, la verdad)
La otra opción es meter el archivo en un vector de bytes y leer éste de detrás hacia delante.
| Código: |
FILE *archivo;
char *caracteres;
long int comienzo, longitud,i;
int contadores[3]={0,0,0};
archivo=fopen("entrada.txt","rb");
fseek( archivo, 0L, SEEK_END );
longitud = ftell( archivo );
rewind( archivo );
caracteres= (char*) malloc(longitud);
fread( caracteres, 2, longitud, archivo );
fclose(archivo);
for (i=longitud-1;i>0;--i) {
printf("%c".caracteres[i]);
}
|
Cabe la remota posibilidad de que se pueda invertir la lectura secuencial de un FILE para que el fget retrocediera en vez de avanzar, pero lo dudo. Si alguien lo sabe que lo diga.
Venga suerte. |
| | Volver arriba | | | EgLoMeR
Registrado: 10 Sep 2006
Mensajes: 15
| | Publicado: 21/09/2007 3:22 am | | | Título: |
| Hola DCelso, muchísimas gracias por tu respuesta.
El problema es que tu código lo que me pasa a caracteres son los caracteres que tiene el .txt, y yo lo que quiero que almacene dentro de ese vector es la cadena de 0 y 1 que componen dicho archivo. Alguna idea?
Gracias. |
| | Volver arriba | | | | cheroky
Registrado: 22 Sep 2005
Mensajes: 1372
Ubicación: En ecx esperando un call
| | Publicado: 21/09/2007 4:16 am | | | Título: |
| Creo que te falta algo de iniciativa.
Una vez que tienes el array que compone el fichero puedes visualizar los bits de cada caracter pasandolo por una funcion del estilo
| Código: | #include <stdio.h>
#include <limits.h>
#define BT(v, p) ((v) & 1 << (p)) ? '1' : '0'
#define LIM sizeof(char) * CHAR_BIT;
void desbit(char *s)
{
int i = LIM;
do {
while(i--) putchar( BT(*s,i) );
putchar('\n');
i = LIM;
}while(*s++);
} |
S2.
_________________
- Explícito es mejor que implícito.
- Simple es mejor que complejo.
- Complejo es mejor que complicado.
- Plano es mejor que anidado.
- Ralo es mejor que denso. |
| | Volver arriba | | | Karman
Registrado: 15 Oct 2005
Mensajes: 308
| | Publicado: 21/09/2007 6:06 am | | | Título: |
| si lo que quieres es obtener los datos en el orden inverso al del archivo... se puede usar una pila:
| Código: |
typedef struct Nodo{//Registro lista...
char txt;
struct Nodo *sig;
}*ND;
ND Q,P=NULL,PRIM=NULL;//Lista
FILE *fp;char *Fname;
/*****************************/
fp=fopen("lista.txt","r");
if(!fp)return false;
while(!feof(fp)){
P = (ND)malloc(sizeof(Nodo));
P->txt=fgetc(fp);
P->sig=PRIM;
PRIM=P;
}
Q=(ND)PRIM;
printf("\n\n");
while(Q!=NULL){
P=Q->sig;
printf("%c",Q->txt);
free(Q);Q=P;
}
fclose(fp);
/************************/
|
S2
_________________
www.inexinferis.co.nr
-. Karman .- |
| | Volver arriba | | | DCelso
Registrado: 28 Abr 2004
Mensajes: 112
| | Publicado: 21/09/2007 7:56 am | | | Título: |
| Es muy estraño lo que pretendes hacer. Con toda la información de este post he sacado esta posible solucion
| Código: |
void pasar_a_base2_invertida(int i_numero, char * salida)
{
int cociente = i_numero;
int resto=0;
int i=0;
while (cociente >= 2) {
resto=cociente%2;
cociente=cociente/2;
salida[i++]=(char)('0'+resto);
}
salida[i++]=(char)('0'+cociente);
salida[i]=0;
}
typedef struct Nodo
{
int txt;
struct Nodo *sig;
}
*ND;
////////
ND Q,P=NULL,PRIM=NULL;//Lista
FILE *fp;
int i,c;
char buffer[255];
fp=fopen("lista.txt","rb");
if(!fp)
return false;
printf("Al as: ");
while((c=fgetc(fp))!=EOF) {
pasar_a_base2_invertida(c,buffer);
for (i=strlen(buffer)-1;i>=0;--i) {
printf("%c",buffer[i]);
}
P = (ND)malloc(sizeof(Nodo));
P->txt=c;
P->sig=PRIM;
PRIM=P;
}
Q=(ND)PRIM;
printf("\n\n");
printf("Al reves: ");
while(Q!=NULL) {
P=Q->sig;
pasar_a_base2_invertida(Q->txt,buffer);
printf("%s",buffer);
free(Q);
Q=P;
}
fclose(fp);
/////////////////
|
Ya me contarás si te ha servido |
| | Volver arriba | | | | rir3760
Registrado: 01 Oct 2004
Mensajes: 3657
Ubicación: Mexico
| | Publicado: 21/09/2007 8:45 am | | | Título: |
| | EgLoMeR escribió: | | El problema es que tu código lo que me pasa a caracteres son los caracteres que tiene el .txt, y yo lo que quiero que almacene dentro de ese vector es la cadena de 0 y 1 que componen dicho archivo. |
Llamame obtuso pero sigo sin entender cual es la estructura exacta del archivo.
Tu objetivo es procesarlo como una secuencia de:
A) enteros cada uno con un tamaño de N bytes.
B) caracteres.
C) bits donde cada byte esta constituido de N bits.
En mi opinion para imprimir la secuencia al reves la forma mas corta es mediante una funcion recursiva y la mas sencilla mediante un bloque de memoria ya sea estatico (un array) o dinamico (malloc et al o (mejor todavia) el par new + delete).
Un saludo
_________________
The capacity to learn is a gift;
The ability to learn is a skill;
The willingness to learn is a choice.
--
Rebec of Ginaz |
| | Volver arriba | | | EgLoMeR
Registrado: 10 Sep 2006
Mensajes: 15
| | Publicado: 22/09/2007 4:32 am | | | Título: |
| muchísimas gracias a todos, la verdad esq estáis hechos unos fieras en esto (no como yo... xD)
DCelso, eso es precisamente lo que quería, solo que en vez de salirme los 8 bits de cada caracter me salen 7 (se come el 0 del principio), pero ya estoy trabajando en ello.
Muchas gracias Kartman, cheroky y DCelso! |
| | Volver arriba | | | | |
| No puede crear mensajes
No puede responder temas
No puede editar sus mensajes
No puede borrar sus mensajes
No puede votar en encuestas
|
|
| |
F.A.Q.
Conéctese para revisar sus mensajes