|
|
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 - Leber
Páginas: [1]
1
« en: Miércoles 21 de Diciembre de 2011, 15:46 »
Buenos dias,
Mi pregunta es si hay alguna manera de saber con la API de linux si cierto fichero esta siendo usado por algun proceso ( si esta abierto digamos ).
La funcion stat no sirve, ya que da todos los datos sobre el fichero pero este no, y tampoco quiero hacer una busqueda en /proc/[pids]/[fd] para saber si ahi se encuentra el fichero, ya que perderia mucho tiempo.
Se os ocurre algo?
Gracias
2
« en: Jueves 25 de Agosto de 2011, 13:10 »
Hola, que tal.
Llevo un par de dias intentando implementar el algoritmo de huffman ( solo por aprender un poco más ), y a pesar de haber leido varios textos todavía tengo algunas dudas que no consigo resolver, a ver si alguien puede echarme una mano.
De momento tengo hecho:
- Tabla con valor-frequencia.
- Lista enlazada con los valores de la tabla ordenada de menor a mayor.
Es decir, teniendo la frase: "hola papa":
hola papa
Table [ 0 ] Char: Freq: 1
Table [ 1 ] Char: o Freq: 1
Table [ 2 ] Char: h Freq: 1
Table [ 3 ] Char: l Freq: 1
Table [ 4 ] Char: p Freq: 2
Table [ 5 ] Char: a Freq: 3
Total r 6
List: Char: Freq: 1
List: Char: o Freq: 1
List: Char: h Freq: 1
List: Char: l Freq: 1
List: Char: p Freq: 2
List: Char: a Freq: 3
Segun lo leido, el arbol huffman se forma así:
Teniendo eso: [espacio](1) - o(1) - h(1) - l(1) - p(2) - a(3)
- Se toman los dos valores con menos frequencia, por ejemplo: ( [espacio] y o ) y se forma un arbol:
( 2 )
/ \
" "[1 peso] o[1 peso]
Y seguimos, ahora nos quedan: h(1) - l(1) - 2 - p(2) - a(3)
Así que cogemos "h" y "l".
Mi duda es que, a mi parecer, h y l deberían quedar asi:
( 4 )
/ \
( 2 ) ( 2 )
/ \ / \
" "[1] o[1] h(1) l(1)
Y nos queda: p(2) - a(3) - 4
Cogemos p( 2 ) y a(3):
( 9 )
/ \
( 4 ) ( 5 )
/ \ / \
( 2 ) ( 2 ) p(2) a(3)
/ \ / \
" "[1] o[1] h(1) l(1)
Y nos queda: 4:
( 14 )
/ \
( 9 ) ( 4 )
/ \
( 4 ) ( 5 )
/ \ / \
( 2 ) ( 2 ) p(2) a(3)
/ \ / \
" "[1] o[1] h(1) l(1)
Así que de esta forma quedaría el arbol, pero creo que no es correcto.
A ver si me podéis decir donde me voy del plano y me pierdo.
Gracias de antemano
3
« en: Miércoles 11 de Mayo de 2011, 18:51 »
Hola, que tal. Leyendo un libro, me surgió una duda que no logro aclarar por mas que lo leo. He leido que en una variable de 8 bits(1 byte), usando un complemento a 2, el rango oscila de -128 a 127, mientras que usando complemento a 1, va de -127 a 127. Estamos hablando de variables con signo claro. He mirado el archivo limits.h: # define CHAR_BIT 8 /* Minimum and maximum values a `signed char' can hold. */ # define SCHAR_MIN (-128) # define SCHAR_MAX 127
Así que supongo que usan complemento a 2. Pero no logro ver porque usando complemento a 2, el numero negativo es -128, mientras que usando 1 es -127. Por lo que he leido, el C2(complemento 2) es igual a: C1+1, pero no se si va por ahi la cosa. Estoy bastante liado la verdad. Este es el enlace que estoy leyendo, y que de ahí surgió la duda: http://users.powernet.co.uk/eton/kandr2/krx304.htmlNo se si me he explicado bien, llevo todo el dia con esto y tengo la cabeza muy espesa ya. Gracias de antemano
4
« en: Miércoles 13 de Abril de 2011, 22:18 »
Hola, quizás el titulo no es muy descriptivo. Intentare explicarme: Supongamos un array como este: int enteros[2] = {4 ,5 };
Para acceder a su contenido puede hacerse: o La segunda forma, por lo que he podido comprobar, toma la dirección en la que empieza la variable enteros, y dado que un entero ocupa 4 bytes, le suma 4 a la direccion base para así obtener el contenido del segundo indice. Sería algo como: 0x7fff00a49620(dirección del primer indice de enteros) + 4. Creo que no me equivoco, es así, no? Ahora bien, leyendo por ahí vi que decían que la segunda forma es más rápida y eficiente que la primera. Y mi pregunta es, de que forma esta accediendo con enteros[1] para que sea menos rápido ? Gracias de antemano
5
« en: Martes 12 de Abril de 2011, 10:40 »
Hola que tal. Estaba haciendo algo cuando me tope con la necesidad de hacer un casteo de tipo void* a int. Como no lo tenia muy claro me puse a buscar un poco por internet y me encontré una web bastante maja donde lo explicaban. En la web había un ejemplo más o menos como este: #include <stdio.h> void func(void *point) { int ret; ret = *(int *)point; } int main(void) { int ret_point = 5; func(&ret_point); return 0; }
El punto es que no entiendo muy bien esto: (int *)point <- Esto lo entiendo, hace un casteo a un puntero de tipo int. Pero luego esto *(int *)point ya no lo entiendo. Alguien me lo podría explicar un poco? Gracias de antemano
6
« en: Viernes 8 de Abril de 2011, 13:07 »
Hola, que tal. Estoy leyendo un manual de asm, pero el codigo que muestran es de 32 bits, y mi máquina es de 64. Algunos ejercicios puedo hacerlos igual, pero cuando empiezan a manejar la pila también empiezan mis dolores de cabeza. Imaginemos este, (lo he hecho yo para probar un poco): # decreases.s Decrementa un valor hasta 0 .section .data number: .int 8 frase: .asciz "Res: %dn" .section .text .globl _start _start: nop mov $1, %eax mov number, %ebx loop: dec %ebx je just pushl %ebp pushl %ecx movl %ebx, 4(%esp) movl $frase, (%esp) call printf addl $8, %esp jmp loop just: mov $0, %ebx int $0x80
Y luego hago: as --32 decreases.s -o decreases.o
y ld -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o decreases -lc decreases.o
Pero en mi maquina me devuelve: ld: skipping incompatible /usr/lib/libc.so when searching for -lc ld: skipping incompatible /usr/lib/libc.a when searching for -lc ld: cannot find -lc
Pero en otra maquina me lo hace correctamente. Las diferencias son: En mi máquina: ls -l /lib/ld-linux.so.2 lrwxrwxrwx 1 root root 20 2011-02-02 14:09 /lib/ld-linux.so.2 -> /lib32/ld-linux.so.2
En la otra: ls -l /lib/ld-linux.so.2 lrwxrwxrwx 1 root root 9 2011-01-28 14:21 /lib/ld-linux.so.2 -> ld-2.7.so
Tenéis alguna idea, seguramente algo estoy haciendo mal, pero no caigo. Gracias de antemano
7
« en: Jueves 7 de Abril de 2011, 18:50 »
Hola, Estaba buscando información sobre las EDD en arbol, pero no arboles binarios, si no arboles que puedan tener mas de 2 hijos. Buscando he encontrado algunos enlaces pero casi todos se referían a arboles binarios, o profundizaban demasiado poco en los arboles del otro tipo. Me preguntaba si tendríais algún enlace donde explicaran minimamente bien esa parte, y mostraran como implementarlo. Los enlaces que he mirado yo son: http://c.conclase.net/edd/?cap=006#iniciohttp://computacion.cs.cinvestav.mx/~aca ... ode57.html------ Aprovecho también a preguntar algo, a ver si estoy enfocando bien el problema. Imaginad una radio que va reproduciendo canciones aleatorias , pero hay la opción de que en determinado momento queramos sintonizar el artista que esta sonando en esos momentos(eso quiere decir todos los discos y canciones de ese artista), o queramos sintonizar un disco en concreto. Lo que he pensado es que como un arbol puede tener ramas "infinitas", la estructura en arbol me serviría para ambas cosas ya que: [SINTONIZAR ARTISTA] [NODO ROOT] | | [ARTISTA] | | [Disco1 - (rama1)]---------[Disco2 - (rama2)] ---------------------etc | | | | [Canciones disco 1] [Canciones disco 2]---------------------etc No se si me explico. Creo que esta estructura es la que me puede ir mejor para este caso, a ver que pensáis vosotros. Saludos y gracias de antemano
8
« en: Viernes 1 de Abril de 2011, 12:55 »
Hola, que tal.
Desarrollando una aplicacion, estoy usando una API de sonido que permite crear un stream(llenar el buffer) de manera asincrona sin bloquear la apliación, y una vez ha terminado, llama a un callback para procesar el sonido. Mi duda viene de que no entiendo muy bien como lo hace internamente. Para ser sinceros comprendo lo que significa hacerlo asíncrono, pero no así la manera de llevarlo a cabo.
Lo que he pensado es que quizas lo que hace es que, si se le especifica que no sea bloqueante, crea un nuevo thread para procesar esa petición y cuando termina llama a la funcion callback, de mientras el mainthread sigue su curso.
Se que no es muy bien una duda específica de C, es solo que me gustaría entender la filosofia de las llamadas asíncronas y como son tratadas. Más que nada para saber un poquito más.
No se si podriais explicarme un poco como funcionan las llamadas asíncronas.
He leido un par de links sobre esto, pero no acaba de quedarme claro del todo.
Gracias de antemano
9
« en: Miércoles 30 de Marzo de 2011, 22:42 »
EDITO Disculpa, lo escribí con prisas  Basicamente es: Tienes una estructura tal que asi: typedef struct _iobuf { int cnt; //Caracteres que quedan en la memoria intermedia char *ptr; //Puntero al siguiente carácter de la memoria intermedia char *base; //Puntero al inicio de la memoria intermedia int flag; //Modo de acceso al fichero int fd; //Descriptor del fichero }FILE;
Ahora, supongamos que tienes dos punteros a FILE, uno para el fichero a copiar(llamemosle flujo1), y el otro para el fichero destino(flujo2). Entonces, lo que haces es: Primeramente lees 1024 bytes(por decir algo) del flujo1, los pones en un puntero (char *base) y luego haces ptr = base. Entonces, cada vez que haces un getc para tomar el siguiente carácter, se hace una comprobación, si nos hemos quedado sin memoria intermedia (--flujo1->cnt <0) , la volvemos a llenar, si todavía tenemos se toma el caracter de flujo1->ptr++ Cuando haces un putc, para copiar el carácter al fichero, también se comprueba si hay memoria intermedia. Si no la hay, se reserva memoria para el puntero flujo2->base del tamaño de 1024 bytes y hacemos que flujo2->ptr = flujo2->base, y se van colocando los caracteres en flujo2->ptr++ = caracter_a_poner
a media que se decrementa como antes. Una vez flujo2->cnt llega a 0, se escribe en el fichero lo contenido en , se coloca de nuevo el puntero al inicio de la memoria intermedia flujo2->ptr = flujo2->base
y se vuelve a reservar memoria. Entonces, como ves, unicamente se copia a disco cuanto contiene los 1024 bytes que hemos leido con antes. Mi duda era porque no copiarlos de golpe, sin esperar a que la memoria intermedia este llena? Espero que ahora me haya explicado mejor
10
« en: Lunes 28 de Marzo de 2011, 13:54 »
Hola, que tal. Con un proyecto que estoy haciendo, necesito capturar eventos a base de teclas, y de momento va bien hasta que me topo con la necesidad de usar las arrowkeys, que como algunas otras teclas, no tienen un codigo ascii, sino dos. Segun esta web: http://www.jimprice.com/jim-asc.shtml , el primer codigo es una tecla de escape que varia segun el lenguaje. En C parece ser el 27, (codigo que pertenece a la tecla ESC). Pero el segundo codigo que me sale no me cuadra demasiado, ya que me dice que cualquiera de las 4 flechas tiene el codigo 91. Aqui os dejo el codigo que hago servir, quiza es que este haciendo algo mal. #include <stdio.h> int main(void) { int key; if(key == 27) { } return 0; }
Y aqui la salida: Presionando el '+': test@sistemes-test:~/c/dl$ ./keys + 43
Presionando ESC: test@sistemes-test:~/c/dl$ ./keys ^[ 27 10
Presionando Uparrow test@sistemes-test:~/c/dl$ ./keys ^[[A 27 91
Presionando Leftarrow test@sistemes-test:~/c/dl$ ./keys ^[[C 27 91 test@sistemes-test:~/c/dl$
Gracias de antemano
11
« en: Martes 16 de Diciembre de 2008, 17:52 »
Buenas a todos, tengo una duda al liberar una lista doblemente enlazada circular: Aqui os adjunto el codigo que tengo: #include <stdio.h> #include <stdlib.h> struct __double_list { int num; struct __double_list *next, *prev; }; int __creat_head(struct __double_list **list); int __insert(struct __double_list **list, int __number); void show(struct __double_list *head); void destroy(struct __double_list **list); int main() { struct __double_list *__list = NULL; int __number_to_put; if( (__creat_head(&__list)) != 0) return -1; for( __number_to_put = 0 ; __number_to_put < 5 ; __number_to_put++) { if( (__insert(&__list, __number_to_put)) != 0) { printf("Error de memn"); return -1; } } show(__list); destroy(&__list); //show(__list); Es para probar si esta bien liberada return 0; } int __creat_head(struct __double_list **list) { *list = (struct __double_list *)malloc(sizeof(struct __double_list)); if(*list == NULL) { perror("Error de mem"); return -1; } (*list)->next = (*list)->prev = *list; return 0; } int __insert(struct __double_list **list, int __number) { struct __double_list *new; new = (struct __double_list *)malloc(sizeof(struct __double_list)); if(new == NULL) { perror("Error new"); return -1; } printf("Number-> %dn",__number); new->num = __number; new->next = *list; new->prev = (*list)->prev; (*list)->prev->next = new; (*list)->prev = new; return 0; } void show(struct __double_list *head) { struct __double_list *node; node = head->next; while(node != head) { printf("Node num->%dn",node->num); node = node->next; } } void destroy(struct __double_list **list) { struct __double_list *node, *aux; node = (*list)->next; while(node != *list) { aux = node; node = node->next; free(aux); } *list = NULL; }
No me convence, porque si vuelvo a mostrar la lista, me muestro 20 veces numeros muy extraños, cuando no deberia de mostrar nada, deberia salir del bucle y ya esta, es por eso que creo que esta mal la funcion de borrar la lista. A ver si me podeis echar un cable; Gracias de antemano & saludos ---------------- Ya lo solucione, fue un fallo bastante grave, jeje, al final la funcion quedo asi: void destroy(struct __double_list **list) { struct __double_list *node, *aux; node = (*list)->next; while(node != *list) { aux = node; aux->next->prev = aux->prev; aux->prev->next = aux->next; node = node->next; free(aux); } *list = NULL; }
Gracias
12
« en: Miércoles 10 de Diciembre de 2008, 23:28 »
Buenas señores, bueno, veran, tengo una duda: Como hacer para saber el tipo de fichero Es decir, lo mismo que hace la utilidad "file" de linux, por ejemplo: < /dev/null > file Vendeta.mpg Vendeta.mpg: MPEG sequence, v1, system multiplex < /dev/null > file amule_download amule_download: symbolic link to `.aMule/Incoming/'
He buscado en el man, y veo que recoje la informacion de /etc/file/magic, mirando los magic numbers y demas, y me he estado ojeando el archivo, pero no acabo de aclararme. He probado de buscar el src de la utilidad "file", para fijarme en el codigo y ver como trabaja para saber como puedo hacerlo y, pero no lo encuentro. Agradeceria cualquier idea, aporte, documento etc.. Gracias de antemano
13
« en: Jueves 30 de Octubre de 2008, 00:05 »
Buenas, escribo esto porque he intentado buscar documentacion, o algun tutorial de fmod Ex, pero solo he encontradoa cerca de fmod3, y era para a ver si alguien podia facilitarme algun link sobre fmod ex, algun manual basico donde se explique su funcionamento, cualquier cosa para empezar en C (si es en cualquier otro lenguage no pasa nada, solo es para ver el funcionamiento, y aprender un poco).
Uso FMOD EX 4.18 bajo linux.
Gracias de antemano
14
« en: Jueves 16 de Octubre de 2008, 00:53 »
Buenas, tengo un problema: Ayer hice una pequeña agenda de notas para practicar un poco, un fichero binario con estructuras, todo funciona bien menos al mostrarme los datos, que hay algunas notas que se repiten( esto no se si es problema de al mostrar datos, o al escribirlos en el fichero) Por ejemplo: Yo le inserto en Catalan la nota 1 y hago un listado de notas y me muestra: Notas [Catalan]: > 1 Notas [Castellano]: Notas [Matematicas]: Notas [Ingles]:
Notas [Catalan]: > 1 > 1 Notas [Castellano]: Notas [Matematicas]: > 5 Notas [Ingles]:
Como ven, salen 2 "1", uno lo puse yo, pero y el otro? He revisado una y otra vez el codigo y no encuentro nada que pueda ser: Las estructuras son estas: typedef struct { int nota_catalan; int nota_castellano; int nota_mates; int nota_ingles; }MATERIAS; typedef struct __notas { int trimestre; MATERIAS m; struct __notas *sig; }NOTAS;
Las funciones de escribir, leer son estas:
Escribe en un fichero la estructura con las notas int carga_fichero(int nota, int materia, int trimestre) { int df; nodo p; if(( df = open("notas.dat",O_WRONLY | O_APPEND | O_CREAT,0600)) == -1) { perror("notas.dat"); return -1; } p=inicializa(p); if(!p) return -1; if( materia == 1) p->m.nota_catalan=nota; else if( materia == 2 ) p->m.nota_castellano=nota; else if( materia == 3) p->m.nota_mates=nota; else if( materia == 4) p->m.nota_ingles=nota; else { fprintf(stderr,"Materia [%d] desconocidan",materia); return -1; } p->trimestre=trimestre; write(df,p,sizeof(NOTAS)); free(p); close(df); return 0; }
lista carga_notas(void) { nodo p; int d_n; int r_bytes; lista l=NULL; int indice=0; if(( d_n = open("notas.dat",O_RDONLY)) == -1) { perror("2datos.dat"); return NULL; } p=inicializa(p); if(!p) return NULL; while(( r_bytes=read(d_n,p,sizeof(NOTAS)) ) > 0) { p->sig=l; l=p; p=inicializa(p); } free(p); close(d_n); return l; }
Muestra notasvoid mostrar_total_notas(lista l, unsigned int assig) { nodo p; p=l; while(p) { if(assig == 0) { if ( p->m.nota_catalan != 0) { printf("NOTAS CATALANn"); printf("> %dn",p->m.nota_catalan); } } else if(assig == 1) { if(p->m.nota_castellano != 0) printf("> %dn",p->m.nota_castellano); } else if(assig == 2) { if(p->m.nota_mates != 0) printf("> %dn",p->m.nota_mates); } else { if(p->m.nota_ingles != 0) printf("> %dn",p->m.nota_ingles); } p=p->sig; } }
Yo no le veo nada extraño, y de hecho no se porque me lo hace..., a ver si alguien puede arrojar un poco de luz, porque estoy algo preucupado. Muchas gracias
15
« en: Martes 25 de Marzo de 2008, 17:50 »
Buenas, estaba haciendo un programilla que buscara ficheros acabdos en ~, pero hay un problema. Primero les enganchare el codigo y luego lo comento: void buscar(char *home,const char *destino) { DIR *dirp; struct dirent *dir; int fd,i,de,ds,nbytes; char *duplicado; char *pathdest; char *pathhome; char buffer[BUFSIZ]; if((dirp=opendir(home))==NULL) { perror(home); exit(-1); } if((pathdest=(char *)calloc(80,sizeof(char)))==NULL) { perror("malloc"); exit(-1); } if((pathhome=(char *)calloc(80,sizeof(char)))==NULL) { perror("malloc home"); exit(-1); } printf("memoria reservada\n"); while((dir=readdir(dirp))!=NULL) { printf("empezando while\n"); duplicado=strdup(dir->d_name); for(i=strlen(dir->d_name)-1;i>0;i--) if(duplicado[i]=='~') { pathhome=(char *)realloc(pathhome,((strlen(home))+((strlen(dir->d_name))))); pathdest=(char *)realloc(pathdest,((strlen(destino))+((strlen(duplicado))))); sprintf(pathhome,"%s/%s",home,duplicado); sprintf(pathdest,"%s/%s",destino,duplicado); if((fd=creat(pathdest,0666))==-1) { perror(pathdest); exit(-1); } if((de=open(pathhome,O_RDONLY))==-1) { perror(pathhome); exit(-1); } if((ds=open(pathdest,O_WRONLY))==-1) { perror(pathdest); exit(-1); } while((nbytes=read(de,buffer,sizeof(buffer)))>0) if((write(ds,buffer,nbytes))!=nbytes) fprintf(stderr,"Error de escritura en %s\n",ds); close(de); close(ds); if((unlink(pathhome))==-1) { perror(pathhome); exit(-1); } // printf("petando aqui\n"); } //printf("hola\n"); printf("repitiendo while\n"); } printf("acabando\n"); closedir(dirp); free(source); printf("source liberado\n"); free(destdir); printf("des liberado\n"); free(pathdest); printf("pathdest liberado\n"); free(duplicado); printf("duplicado liberado\n"); free(pathhome); printf("pathhome liberado\n"); }
El error esta en free(pathhome), ya que me peta ahi, cuando libero la memoria de pathhome. Como ven primero le asigno 80 bytes al empezar el programa, luego cada vez que se encuentra un fichero acabado en ~, le reasigno la lontigud del directorio mas la del nombre del fichero, y bueno, todo va bien hasta el momento de liberar la memoria que acaba con un: *** glibc detected *** ./backups: free(): invalid next size (fast): 0x0804c0c8 *** ======= Backtrace: ========= /lib/i686/cmov/libc.so.6[0xb7e9b915] /lib/i686/cmov/libc.so.6(cfree+0x90)[0xb7e9f380] ./backups[0x8049092] ./backups[0x8048cb0] /lib/i686/cmov/libc.so.6(__libc_start_main+0xe0)[0xb7e46450] ./backups[0x80487f1] ======= Memory map: ======== 08048000-0804a000 r-xp 00000000 08:06 639238 /home/null/mis_programas/backups 0804a000-0804b000 rw-p 00001000 08:06 639238 /home/null/mis_programas/backups 0804b000-0806c000 rw-p 0804b000 00:00 0 [heap] b7d00000-b7d21000 rw-p b7d00000 00:00 0 b7d21000-b7e00000 ---p b7d21000 00:00 0 b7e15000-b7e21000 r-xp 00000000 08:02 354860 /lib/libgcc_s.so.1 b7e21000-b7e22000 rw-p 0000b000 08:02 354860 /lib/libgcc_s.so.1 b7e2f000-b7e30000 rw-p b7e2f000 00:00 0 b7e30000-b7f77000 r-xp 00000000 08:02 370991 /lib/i686/cmov/libc-2.7.so b7f77000-b7f78000 r--p 00147000 08:02 370991 /lib/i686/cmov/libc-2.7.so b7f78000-b7f7a000 rw-p 00148000 08:02 370991 /lib/i686/cmov/libc-2.7.so b7f7a000-b7f7d000 rw-p b7f7a000 00:00 0 b7f89000-b7f8c000 rw-p b7f89000 00:00 0 b7f8c000-b7fa8000 r-xp 00000000 08:02 354818 /lib/ld-2.7.so b7fa8000-b7faa000 rw-p 0001b000 08:02 354818 /lib/ld-2.7.so bfb95000-bfbaa000 rw-p bfb95000 00:00 0 [stack] ffffe000-fffff000 r-xp 00000000 00:00 0 [vdso] Abortado
El error es : " free(): invalid next size (fast): 0x0804c0c8", y como ven todo va bien hasta que se intenta liberar su memoria: acabando
source liberado
des liberado
pathdest liberado
duplicado liberadoPeta ahi. La verdad no se que estoy haciendo mal, si alguien pudiera ayudarme... se lo agradeceria mucho. Gracias de antema
Páginas: [1]
|
|
|
Mostrar Mensajes
