|
|
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.
Mensajes - Leber
26
« en: Miércoles 13 de Abril de 2011, 18:33 »
Puedes leerlos a traves de comparaciones para saber cual esta seleccionado, o puedes mostrar su valor (aunque el valor sera un entero que no te servira de mucho). Mira, aquí te dejo un ejemplo: #include <stdio.h> enum { FUET, CHORIZO, QUESO }embutido; int main(int argc, char **argv) { embutido = FUET; switch( embutido ) { break; case CHORIZO : printf("Chorizon"); break; case QUESO : printf("Quesoon"); break; } return 0; }
27
« en: Martes 12 de Abril de 2011, 13:41 »
El asterisco de más es para recoger el valor al que apunta el puntero. Esto viene en cualquier libro de C  Si, eso si que lo se, simplemente me lie con el ( tipo *). saludos 
28
« 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
29
« en: Viernes 8 de Abril de 2011, 13:44 »
Entonces supongo que tendré que instalarme un SO de 32bits. Yo creía que diciendole que generara código de 32bits podía salvar esto. Gracias por responder
30
« 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
31
« en: Jueves 7 de Abril de 2011, 23:52 »
En verdad, mi compilador casi se rompe. Tu código contenía bastantes erratas de sintaxis. Faltaban ";" , habías puesto mail en lugar de email. una P cuando tenia que ser p, el prototipo de la función nuevonodo estaba incompleta. Despues de corregir eso, tu código queda así: A mi me lanza un error porque no tengo la libreria conio (que no es estandart): #include <stdio.h> #include <stdlib.h> #include <string.h> #include <conio.h> struct agenda{ char nombre [50]; char telefono[25]; char email[50]; }; struct nodo{ struct agenda dato; struct nodo *proximo; } ; struct nodo *nuevonodo(void); int colavacia(struct nodo *); struct nodo *creacola (struct nodo *, struct agenda); void mostrar (struct nodo *); void main() { struct nodo *pri=NULL, *ult=NULL; struct agenda x; while (strcmp(x. nombre, "fin")) { printf ("ingrese telefono: "); ult=creacola(ult,x); if (pri==NULL) pri=ult; //si es la 1 pasada pongo en pri el valor del primer nodo } if (colavacia(pri)==1) { } else mostrar(pri); } struct nodo *nuevonodo() { struct nodo *p; p =(struct nodo *)malloc(sizeof(struct nodo )); if(p==NULL) { } return p; } struct nodo *creacola(struct nodo *ult, struct agenda x) { struct nodo *p; p=nuevonodo(); (*p).dato=x; (*p).proximo=NULL; if(ult!=NULL) (*ult).proximo=p; //si hay nodo anterior en prox pongo la direccion del nodo actual return p; } int colavacia(struct nodo *pri) { if(pri==NULL) return 1; else return 0; } void mostrar (struct nodo *pri) { struct nodo *aux; while(pri!=NULL) { printf("Nombre: %s - telefono: %s - Mail: %s n", pri->dato.nombre,pri->dato.telefono,pri->dato.email); aux=pri; pri=(*pri).proximo; } }
32
« 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
33
« en: Martes 5 de Abril de 2011, 14:23 »
Tu código tiene bastantes errores, y son más de atención que no de otra cosa. Por empezar: Esto no sirve de nada si luego haces esto: typedef struct datos{ char nombre[13]; char apellido[13]; int edad; char sexo; float altura; }inf_datos;
Para coger cadenas con scanf, se hace: scanf("%s",alumno [i ]. apellido);
Y no: scanf("%s",&alumno [i ]. apellido);
Luego, el campo sexo es de 1 byte, y tu estas cogiendo como una cadena de bytes: scanf("%s",&alumno [i ]. sexo);
Debería ser: scanf("%c",&alumno [i ]. sexo);
Añadiendole más leña: printf("nEl Nombre del Alumno es: %s",alumno [j ]. edad);
es de tipo entero, por qué lo muestras como si fuera una cadena? Creo que deberías coger un libro y mirartelo un poco, ya que son errores de no prestar atención. Saludos
34
« en: Viernes 1 de Abril de 2011, 17:35 »
Bueno, me refería a que cuando leia los tutoriales que mostraban como usar hilos con pthreads, no vi que las variables que usaban los distintos hilos fuesen volatile.
35
« en: Viernes 1 de Abril de 2011, 17:02 »
Hostia, pues que raro, en ninguno de los manuales que lei acerca de hilos en POSIX hablaban acerca de esto.
36
« en: Viernes 1 de Abril de 2011, 16:24 »
Yo había he usado hilos, en códigos mios para aprender, y si que se que para modificar secciones críticas lo mejor es bloquear el mutex y luego desbloquearlo, lo que no sabía es que las variables debían ser volatiles.
Saludos
37
« en: Viernes 1 de Abril de 2011, 14:42 »
Aún así estás usando multihilo o multiproceso, aunque sea de forma transparente
Igualmente estoy casi convencido que lo hará con hilos u otro proceso si no necesita acceder a la memoria/código de tu proceso. Segun tengo entendido, los hilos a diferencia de los procesos, comparten memoria y código, no? Así que no habría mucho problema si un hilo auxiliar necesita modificar, por ejemplo, una variable global.
38
« en: Viernes 1 de Abril de 2011, 14:27 »
Hola rfog.
Si, entiendo como funciona una callback, lo que me mantiene un poco más en vilo es como la función logra desvincularse para hacer su tarea en segundo plano. Son un poco manias mias, ya seguiré investigando.
Gracias por la información =)
39
« en: Viernes 1 de Abril de 2011, 14:03 »
Si, como yo tampoco lo tengo estoy un poco jodido xD, pero bueno, era más que nada para saber. Había leido que una forma sencilla era implementarlo con hilos, pero no me imagino una manera de hacer algo asíncrono sin hilos, quiero decir, si una aplicacion es ejecutada secuencialmente, no lo veo muy viable. Gracias
40
« 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
41
« en: Viernes 1 de Abril de 2011, 10:35 »
Si, algo lei acerca de esto, sobre el buffer cache y las llamadas a fsync para escribir a disco la información que todavía este en el buffer. Gracias m0skito
42
« en: Viernes 1 de Abril de 2011, 10:22 »
Uhm, más o menos sabía que iba por aquí el asunto, pero no acaba de afinarlo. Entonces, es más rápido llenar un array, esperar a que este completo, y luego escupir todo esto a disco, que ir byte por byte, hasta ahi más o menos lo tengo claro. Lo que ocurre es que me estoy liando. Las llamadas al sistema, por ejemplo write y read, supongo que también trabajan con este tipo de memoria intermedia. Al fin y al cabo, se puede decir que un programa que no trabaje con memoria intermedia, sería tal que así: Y uno que si: Gracias por responder
43
« en: Jueves 31 de Marzo de 2011, 00:26 »
Edite la primera entrada, ya que me di cuenta que lo habia explicado de un modo bastante horrible 
44
« 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
45
« en: Martes 29 de Marzo de 2011, 23:39 »
Quizá quieras ayudarte de fgets y sscanf, van bastante mejor, al menos en mi experiencia, y no son tan propensos a errores como scanf.
Saludos
46
« en: Martes 29 de Marzo de 2011, 23:28 »
Si no sabes cuantas listas tendrás, puedes hacer con edd (estructuras de datos dinámicas) Algo asi: struct ficha { char nombre[20]; char apellido[20]; unsigned int nota; struct ficha *next; };
Si lo sabes, puedes hacer un array de estructuras. Después de entrar todas las fichas que necesites, puedes ordenarlo: Algo como esto: if (ficha[0].nota > ficha[1].nota) { ficha_auxiliar = ficha[1]; ficha[1] = ficha[0]; ficha[0] = ficha_auxiliar; }
Ficha auxiliar sería un tipo de ficha temporal, usarlo solo como auxiliar. Ese método seria por bubblesort, que aunque no es el más eficiente, sirve para esto. Saludos
47
« en: Lunes 28 de Marzo de 2011, 16:23 »
Uhm, no habia caido en eso. Como lo has sabido? Gracias
48
« en: Lunes 28 de Marzo de 2011, 14:08 »
El código de tecla si, es igual, me referia al de escape. Dicen que a veces se antepone un 0, o a veces un 27.
No se, pense que igual que podía capturar la tecla ESC, la tecla +, el espacio, (estos tres no me dan ningun problema), podría hacer lo mismo con las arrowkeys.
Estaba usando GTK para la interfaz, y tiene eventos para capturar teclas, no hay problema, es lo que estoy usando, más que nada era curiosidad de saber como las recupera el.
Gracias por responder
49
« 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
50
« en: Viernes 25 de Marzo de 2011, 18:43 »
En verdad, puedes hacer algo asi. Imagina que tienes un array de enteros,: int numeros[100] Bucle { Lees el numero si es 0 salimos del bucle }
Dado que necesitamos mínimo dos números, si hemos introducido menos salimos del programa. Si no, continuamos. Entonces, podemos sumar los dos primeros números del array, - + [1], y a partir de ahí sumas o restas dependiendo del indice del bucle.
Dado que hemos sumado los dos primeros, el tercero se restaría, el 4 se sumaria. Yo lo haría según el resto que de el indice del segundo bucle % 2. Ejemplo: indice2 < numero_total_de_numeros_entrados si indice %2 != 0 restamos el numero si indice %2 == 0 sumamos el numero
No se si me he explicado bien, estoy algo cansado pero espero que te sirva mas o menos Saludos
|
|
|
Mostrar Mensajes
