SoloCodigo

Muy buena la referencia.

Gracias RadicalEd!

Nos vemos

He estado probando tu código. La función feof la estas usando al revés, debes poner:

Con eso entrarás en el bucle while (si el fichero existe).

Pon atención a tu fread, puesto que sizeof(cad) te devuelve 256, y estas pidiendo 20 bloques de 256 bytes. Si es lo quieres, todo correcto (a mi me dio problemas )

Espero haberte ayudado.

Nos vemos!

Buenas de nuevo. Como dije, parece mentira pero en vacaciones (y mas en navidad) es cuando menos encuentra uno tiempo para dedicarse a sus cosas .

Ya he modificado la ultima implementación, en lo relativo a la creación y modificacion de las pilas. Ahora cada pila es representada como un nodo dentro de una lista enlazada. Cada uno de esos nodos contiene un puntero a la pila en sí, además de un identificador para poder ser localizada.

Bueno, creo que la cosa esta casi lista. Espero posibles correcciones.

Nos vemos

Aunque este post esté en un foro en concreto, me gustaria también expresar mi agradecimiento a todos los componentes del foro por su ayuda y por estar siempre ahi, este foro es el mejor de todos!!!! No tiene ni punto de comparacion con ningun otro, este es punto de referencia.

Espero que aprovechemos todos muy bien las fiestas y disfrutemos en familia de la Navidad. Sed bueno para recibir muuuchos regalos

Feliz Navidad a todos!!!

Nos vemos

Eugenienko, no es una hoja de arbol , si te fijas bien, es un tio con un disquete en sus manos por encima de la cabeza, lo puedes ver mejor en el logotipo de solocodigo, al lado del adorno navideño.

Admin, atento a la pregunta de RadicalEd:

PERO NO TODAS LAS VECES SALE POR QUE ADMIN?

Nos vemos

Bueno, ya estamos de nuevo por aqui. Bienvenido rir3760! gracias por tu ayuda.

He implementado las funciones destruyePila e inviertePila. La variable num_pilas la he convertido en global segun vuestras recomendaciones, además es static pq conviene que solo tenga alcance dentro del codigo de pila.c. Toda llamada a malloc esta comprobada para impedir posibles fallos.

Veamos algunas puntualizaciones que estoy encontrando y creo que puede provocar reestructurar y alterar el codigo:
- Dado que los nodos de las pilas almacenan un puntero a los datos (y dicho puntero es void para intentar un poco de genericidad) el hecho de duplicar una pila me resulta un poco confuso . ¿Como duplico los nodos de una pila si no se cuanto espacio debo reservar para los nuevos nodos? ¿Puedo usar un malloc con el tipo de datos void?.
Por ejemplo, tengo una pila con dos enteros, dichos enteros en la pila realmente son apuntadores a void hacia la zona de memoria donde estan estos valores. Si ahora duplico la pila, duplico los nodos y con ello los apuntadores, pero sigo apuntando a la misma zona de memoria!!! los datos son los mismos!. ¿Como puedo saber cuanta memoria ocupa ese puntero a void (que realmente apunta a int) para poder reservar memoria nueva y duplicar su contenido?
Creo que una buena solución sería saber que tipo de datos se almacena en los nodos, como anteriormente comentaste JuanK, eso ayudaría a reservar memoria y a duplicar su información. ¿Que opinais?

- El problema anterior tambien me ha surgido al intentar implementar la funcion de concatenar pilas. Dado que aunque concatene pilas, la pila resultante tendra nuevos nodos, vale, pero sin embargo dichos nodos tendran apuntadores a los datos que tambien estan siendo apuntados por las pilas que han sido concatenadas.

- Me parece que voy a tener que cambiar el concepto de la variable global pilas. Actualmente es un array a las pilas que estan siendo usadas, y para acceder a una determinada pila el usuario hace uso de su indice (que recibe al llamar a crearPila) y trabajar con la pila. Sin embargo, si por ejemplo tengo tres pilas (la 0, la 1 y la 2) y ahora borro la 1. El numero de pilas usandose es 2, y tendria un hueco en el array en la posicion 1 que podria reutilizarse. Sin embargo, tal y como esta orientado el programa, la variable num_pilas siempre se incrementa para dar nuevas pilas (peligro de desbordamiento en un futuro!!).
Estoy pensando en mantener una lista enlazada que crezca por cada pila que se solicite y que contenga un identificador entero para identificar la pila dentro de la lista. Esto permitiría hacer más llevadero el control de las pilas y su borrado. ¿Se os ocurre algo mejor? ¿Creeis que debería refinar el control de los huecos en el array?

El codigo por ahora queda así:

Archivo pila.h
<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->

/* IMPLEMENTACION DE UNA PILA "GENERICA"
 * --------------------------------------------------------
 *   La siguiente implementacion permite el uso de una pila lo mas generica
 * posible. Existe una estructra nodo que almacena un puntero a la
 * informacion que desea introducirse a la pila. La varaible **pilas almacena
 * las pilas que estan siendo usadas.
 *   La funcion creaPila() devuelve un entero para el acceso a la pila creada
 * que sera usado en las demas funciones. El uso del entero puede asemejarse a
 * un descriptor de archivos.
 */
 
#include <stdio.h>

/* Estructura que actuara como NODO */
struct nodo {
    /* Elemento a almacenar */
    void *elem;
    /* Puntero al elemento siguiente */
    struct nodo *sig;
};

/* Puntero a las pilas que estan siendo utilizadas */
struct nodo **pilas;
/* Variable que mantiene el numero de pilas usadas */
static int num_pilas = 0;

/* Crea una pila. Devuelve el entero para controlarla */
int creaPila();
/* Introduce un elemento en la pila especificada */
void apila(int pila, void *elemento);
/* Desapila un elemento de la pila especificada */
void *desapila(int pila);
/* Recupera el primer elemento de una pila, sin desapilarlo */
void *recupera(int pila);
/* Destruye la pila que se la pasa como parametro */
void destruyePila(int pila);
/* Invierte la pila que se le pasa como parametro */
void inviertePila(int pila);

<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

Archivo pila.c
<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->

/* Implementacion de una pila generica
 */
#include "pila.h"

/* Crea una pila. Devuelve el entero para controlarla */
int creaPila(){
    struct nodo **aux;
    int i;

    if((aux = (struct nodo **) malloc(sizeof(struct nodo *)*num_pilas)) == NULL) {
        perror("Error al crear la pila");
        exit(1);
    }
    for(i = 0; i < num_pilas; i++)
        aux[i] = pilas[i];
    
    if((pilas = (struct nodo **) malloc(sizeof(struct nodo *)*(num_pilas + 1))) == NULL) {
        perror("Error al crear la pila");
        exit(1);
    }

    num_pilas++;
    for(i = 0; i < num_pilas - 1; i++)
        pilas[i] = aux[i];
    
    pilas[num_pilas-1] = NULL;
    return num_pilas-1;
}

/* Introduce un elemento en la pila especificada */
void apila(int pila, void *elemento) {
    struct nodo *aux;

    if((aux = (struct nodo *) malloc(sizeof(struct nodo))) == NULL) {
        perror("Error al apilar");
        exit(1);
    }
    aux->elem = elemento;
    aux->sig = pilas[pila];
    pilas[pila] = aux;
}

/* Desapila un elemento de la pila especificada */
void *desapila(int pila) {
    void *aux;
    struct nodo *act;
    
    if(pilas[pila] != NULL) {    
        aux = pilas[pila]->elem;
        act = pilas[pila];
        pilas[pila] = pilas[pila]->sig;
        free(act);
        
        return aux;
    }
    else return NULL;
}

/* Recupera el primer elemento de una pila, sin desapilarlo */
void *recupera(int pila) {
    return pilas[pila]->elem;
}

/* Destruye la pila que se la pasa como parametro */
void destruyePila(int pila) {
    struct nodo *aux, *aux1;

    aux = pilas[pila];
    while(aux != NULL) {
        aux1 = aux->sig;
        free(aux);
        aux = aux1;
    }
    pilas[pila] = NULL;
}

/* Invierte la pila que se le pasa como parametro */
void inviertePila(int pila) {
    int pilaAux;
    struct nodo *aux, *aux1;

    aux = pilas[pila];
    pilas[pila] = NULL;

    while(aux != NULL) {
        apila(pila, aux->elem);
        aux1 = aux->sig;
        free(aux);
        aux = aux1;
    }
}
<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

La cuestion de ordenar los valores de las pilas lo dejo para un poco más adelante, pues ahora ya me estoy planteando bastante cosas y prefiero perfilar bien esto.

Empece con la implementación de una pila porque pensaba que sería lo más fácil, ya estoy viendo que tiene su intrigulis, jejeje. Veremos cuando pase a la implementacion "generica" de listas simples enlazadas, doblemente enlazadas y demás... Bueno todo se andará.

De nuevo, muchas gracias, pretendo contruir una implementación que nos ayude a todos a usar estas estructuras de datos en cualquier situación sin tener que implementarlas cada vez que las necesitemos. Gracias!

Nos vemos

Hola, dado que la mayoria de los programadores trabajamos mucho con estructuras de datos dinámicas (sobre todo para las practicas de la universidad), me he propuesto crear una serie de implementaciones "genericas" para las estructura de datos dinamicas mas comunes.

He empezado por la implementación de una pila, pues es la más facil en cuanto a funciones a utilizar. El siguiente código administra el uso de una serie de pilas que el usuario puede crear.

El codigo funciona, al menos en las pruebas que he realizado, os invito a probarlo si quereis.

Pero sobre todo, me gustaria que le echarais un vistazo, no solo a la implementación, sino tambien a las funciones principales que facilita esta "mini-libreria". ¿Os resultan suficientes? Si fuerais vosotros los que usarais esta implementación, ¿añadiriais alguna función mas?.

Aqui os lo pongo:

Archivo pila.h
<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->
/* IMPLEMENTACION DE UNA PILA "GENERICA"
 * --------------------------------------------------------
 *
 *   La siguiente implementacion permite el uso de una pila lo mas generica
 * posible. Existe una estructra nodo que almacena un puntero a la
 * informacion que desea introducirse a la pila. La varaible **pilas almacena
 * las pilas que estan siendo usadas.
 *   La funcion creaPila() devuelve un entero para el acceso a la pila creada
 * que sera usado en las demas funciones. El uso del entero puede asemejarse a
 * un descriptor de archivos.
 */
 
#include <stdio.h>

/* Estructura que actuara como NODO */
struct nodo {
    /* Elemento a almacenar */
    void *elem;
    /* Puntero al elemento siguiente */
    struct nodo *sig;
};

/* Puntero a las pilas que estan siendo utilizadas */
struct nodo **pilas;

/* Crea una pila. Devuelve el entero para controlarla */
int creaPila();
/* Introduce un elemento en la pila especificada */
void apila(int pila, void *elemento);
/* Desapila un elemento de la pila especificada */
void *desapila(int pila);
/* Recupera el primer elemento de una pila, sin desapilarlo */
void *recupera(int pila);
<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

Archivo pila.c
<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->
/* Implementacion de una pila generica
 */
#include "pila.h"

/* Crea una pila. Devuelve el entero para controlarla */
int creaPila(){
    static int num_pilas = 0;
    struct nodo **aux;
    int i;

    aux = (struct nodo **) malloc(sizeof(struct nodo *)*num_pilas);
    for(i = 0; i < num_pilas; i++)
        aux[i] = pilas[i];
    
    num_pilas++;
    pilas = (struct nodo **) malloc(sizeof(struct nodo *)*num_pilas);

    for(i = 0; i < num_pilas - 1; i++)
        pilas[i] = aux[i];
    
    pilas[num_pilas-1] = NULL;
    return num_pilas-1;
}

/* Introduce un elemento en la pila especificada */
void apila(int pila, void *elemento) {
    struct nodo *aux;

    aux = (struct nodo *) malloc(sizeof(struct nodo));
    aux->elem = elemento;
    aux->sig = pilas[pila];
    pilas[pila] = aux;
}

/* Desapila un elemento de la pila especificada */
void *desapila(int pila) {
    void *aux;
    struct nodo *act;
    
    if(pilas[pila] == NULL) return NULL;
    
    aux = pilas[pila]->elem;
    act = pilas[pila];
    pilas[pila] = pilas[pila]->sig;
    free(act);

    return aux;
}

/* Recupera el primer elemento de una pila, sin desapilarlo */
void *recupera(int pila) {
    return pilas[pila]->elem;
}
<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

Como veis, la implementación intento que sea genérica utilizando punteros a void. Pero usando C, esa "genericidad" es un poco superficial, pues además acarrea otros problemas como es la uniformidad de los datos que contiene la pila. Esto podría llevarnos a largas disertaciones acerca de la reutilización, modularidad y demás del lenguaje C y de mi implementación, pero no pretendo ir por esos derroteros (aunque si alguno se presta, que no dude en comunicarmelo ).

La implementacion es sencilla y corta, y solo quiero saber vuestra opinion acerca de su utilidad y cosas que podrían faltar y demás. Por supuesto, si detectais algun error, no dudeis en comunicarmelo.

Muchas gracias!

Nos vemos

La funcion strtok devuelve un puntero al siguiente token y modifica la cadena que recibe como parametro (cuidado con eso), creo que no reserva memoria nueva para el puntero que devuelve.

¿Por qué no intentas probar con la función strdup para duplicar las cadenas que te devuelve strtok? Quiza eso te solucione el problema.

Espero haberte ayudado, si no es asi, no dudes en contarnos que te pasa.

Nos vemos

¿Y como es esa otra forma que lo has hecho para que vaya bien al imprimir pero que no vaya bien al guardar las variables?

Es cierto JuanK, eso me recuerda a unas conferencias que estuvieron haciendo los de Microsoft por mi universidad. La plataforma .NET pretende llegar a cualquier electrodomestico o dispositivo que sea capaz que computar algo, pero asi, cualquier cosa. Segun lo que estuvieron contando, "solo" hace falta instalar el conjunto de herramientas de .NET framework y a partir de ahi la cosa es de color de rosa ..

Estuvo genial, tendriais que ver como vendían la plataforma .NET y demás, el conferenciante venia con su movil con Windows, pda con Pocket PC... Nos hizo demostracion de todo, jejejeje, resulto curioso lo "facil" que parece todo, se parecen a los magos, pq lo hacen todo rapido y corriendo como si no quisieran que los asistentes al evento vieran las complicaciones que tiene eso y observaran directamente el resultado final.

La verdad es que la idea es muy buena, solo falta que se adecúe al mercado y a la situacion.

Lo contaba como anecdota

Nos vemos

EDITO: Por cierto JuanK, ta guapo el avatar!!!

No conozco mucho del tema, pero lo poco que he oido hablar y leido por ahi, tampoco se puede decir que exista un lenguaje estandar para la programacion de los dispositivos, y en algunos, simplemente no se si existira.

Conozco electrodomesticos que disponen de una maquina virtual java para poder ejecutar un mini-sistema operativo en java. Otros que llevan linux incrustado (lenguaje C de por medio seguro). Algunos moviles llevan el sistema operativo simbian (se escribe asi?), pero desconozco en que lenguaje esta programado. Las palmOne se construyen basicamente sobre C y C++ creo.

Pero creo que para algunos aparatos, como los mandos de la television, simplemente son circuitos que responden a unos determinados eventos. En lo que respecta al diseño de los circuitos y demas, supongo que usaran algun programa como PSpice o algo asi.

No se, a mi tambien me pica la curiosidad ahora que lo dices, alguien sabe algo mas concreto?

Nos vemos

Si al hacer el printf no te imprime nada en el servidor y es como si no lo leyera, es que la funcion recv es no bloqueante, y si no hay datos que leer no se espera a que lleguen.

Para hacerlo bloqueante o no puedes usar la funcion fcntl, o utilizar la funcion select para comprobar si hay datos para leer durante un determinado periodo de tiempo.

Espero haberte ayudado

Nos vemos

Si mira, visita C con clase y ahi podras consultar las funciones que hemos comentado y algunos ejemplos.

Si tienes algun problema o duda no dudes en decirlo

Nos vemos