SoloCodigo

Bueno asi por encimita...
no debiera haber una función

destruye_pila();

Y por otro lado operaciones como

-copiar pila
-crear copia invertida de la pila

podrian ser de gran utilidad.

Normalmente las librerias de manejo de pilas incluyen otras cosas que no se si esten contempladas dentro de tu alcance:

- Ordenar alfabeticamente
- Ordenar numericamente
- Ordenar alfabeticamente desc
- Ordenar numericamente desc
- 'Concatenar' una pila con otra
- Un metodo que devuelva un string con el contenido de la cabeza de la pila

Otra funcionalidad podria ser por ejemplo que en cada nodo de la pila exista realmente una estructura con un dato tipo void (como ya lo tienes) y un campo que indique que tipo de dato esta almacenado en el nodo, ejemplo


Una recomendacion para tu programacion es que utilices la notacion al 'estilo pascal' creo que se llama...
es decir para que tu codigo sea un poco mas claro los nombres de las funciones deberian comenzar siempre en mayusculas y si son de nombres compuestos deberia ser mayuscula en la pimera letra de un nuevo nombre.

Y la forma que utilizas actualmente para los nombres de las funciones utilizarla para los nombres de las variables.

Mas tarde hare otros comentarios sobre tu codigo.

Uff uff, vayamos por partes . Antes que nada gracias por centrarte y haber analizado mi codigo. Vayamos al lio.

Como ves, la implementacion necesitaba de opiniones acerca de posibles mejoras y correcciones, y agradezco mucho tus opiniones. Las funciones destruyePila, copiaPila, concatenaPila e inviertePila las veo realmente útiles para una libreria de pilas, asi que me propongo implementarlas.

Las funciones que comentas para ordenar numericamente/alfabeticamente solo serían posibles si se conociera el tipo del contenido de los nodos de la pila. Cosa que se puede subsanar con la idea que has propuesto de incluir un campo en los Nodos para indicar el tipo del dato que se incluye. Esto dara mucho juego porque así también se podrán asegurar que los elementos de una pila son del mismo tipo, por ejemplo.Tambien lo veo muy útil, lo implementaré.

En cuanto a tu segundo post y las anotaciones acerca del codigo:
- Sobre el punto 1: He estado revisando algunas fuentes y creo que la palabra reservada static si que esta contemplada en el lenguaje C. Hice ese "trapicheo" para evitar introducir variables globales, con una (que apunta a la estructura de listas) creo que es suficiente.

- Sobre el punto 2: Ves mas correcto hacer:
El resultado es el mismo, quizas es mas elegante? ¿Te referias a eso?. Ok, comprendo la idea, la variable representativa del numero de pilas debe estar en consonancia con el numero de pilas reservadas en memoria, en mi codigo, el programa podría fallar el malloc y no tener la memoria reservada, entonces el valor de num_pilas sería incorrecto. ¿Van por ahi los tiros?

- Sobre el punto 3: Es verdad, debo controlar en todo momento si los malloc y free estan actuando convenientemente. Quizas esto sea un vicio de hacer practicas en la universidad con prisa. Lo tendre que revisar y corregir.

- Sobre el punto 4: Jejeje, tienes razon, si estamos en programacion estructurada, que nuestros procedimientos sigan esa filosofia. Ok, de acuerdo. (Esto me ha recordado a uno de mis profesores ).

Bueno, me pongo al lio en cuanto pueda y comento mis evoluciones.

Muchas gracias JuanK!!!! Eres un genio!

Nos vemos

Volviendo a lo del static , realmente dudo que sea de lenguaje c, pues esta palabra reservada se utiliza para  para mantener un  miembro comun en cada una de las instancias de una clase, y dado que en el lenguaje  C no existe el concepto de clases, es muy seguro que sea de C++ y no de C.

La palabra reservada 'static' forma parte del C estandard, uno de los libros mas conocidos (y antiguos) que describen su uso es 'The C Programming Language 2nd Ed' de Brian W. Kernighan y Dennis M. Ritchie.

Cuando el calificador 'static' se aplica a variables automaticas (locales) cambia el tipo de almacenamiento a estatico por lo que la variable se inicializa a cero (si no se le da un valor inicial) cuando se carga el programa y su duracion continua hasta la terminacion del mismo.

En el caso de variables externas (globales) la palabra reservada 'static' cambia la vinculacion (o 'linkage') a interna por lo cual la variable solo puede ser accesada desde su punto de declaracion hasta el final del archivo de codigo fuente.

Un saludo

pero no estoy seguro de que consecuencias podria tener usarla asi:
static int num_pilas = 0;
ya que podria implicar que se reasiganara 0 cada vez  no?

No, ya que la asignacion solo ocurre una vez al inicar el programa y las llamadas a la funcion creaPila() van a ignorar la asignacion.

Adicionalmente cuando implementes DestruyePila ya no te va a servir igual, pues

Citar

la variable solo puede ser accesada desde su punto de declaracion hasta el final del archivo de codigo fuente.

Realmente entiendo que solo puede ser accesada desde su punto de declaracion hasta donde termina su scope, no hasta el final  del archivo de codigo fuente.

Cierto, pero lo que mencione arriba solo se aplica a variables globales.

En lo que se refiere a la variable num_pilas me parece que lo mas recomendable es lo que sugiere JuanK de definirla como global, si ademas se añade el calificador static tendriamos que las variables globales definidas en el modulo de implementacion (pila.c) no podrian accederse directamente desde el modulo cliente, solo mediante las funciones definidas en la interfaz (pila.h), algo similar a lo que sucede con la encapsulacion y los metodos get/set de la POO.

Un saludo

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

Ya estoy de nuevo. Con esto de las fiestas, uno tiene menos tiempo para entretenerse, aunque deberia ser al reves .

Para el problema que tenia acerca de qué ocupaba cada nodo de la pila (realmente es cuánto ocupaba a lo que apuntaba cada nodo de la pila) he incluido un campo en los nodos que especifica el tamaño (en bytes) de los datos que son apuntados por el campo elem. Así cuando duplico una pila, se cuanta memoria debo reservar y por consiguiente cuánta debo duplicar para cada nodo. La función afectada ha sido apilar, que contiene un parámetro más indicando el número de bytes que ocupan los datos que se apilan. El usuario deberá tener cuidado especialmente con los datos de tipo cadena, pues si usa la función strlen para establecer el contenido, estará pasando por alto el '\0' de fin de cadena, y al duplicar (como uso la funcion memcpy) solo copiaré exactamente la longitud de la cadena, sin incluir el '\0'.

Asi que ya he implementado las funciones de duplicarPila y concatenaPila (la segunda usa a la primera). Tambien he modificado lo del control de errores. Como me has comentado JuanK, he creado una variable global (grrrr, tantas globales...) que se llama errorPila que contiene el error que se ha producido, y las funciones que provocan el error devuelven -1 en caso de haber pasado algo. Si el usuario de la librería quiere comprobar el error, puede acudir a la variable errorPila para ver que ha pasado.

En la función crearPila he desestructurado un poco la implementación para el control de errores, creo que se ve mas claro poner en medio un return -1, porque si empiezo a poner if...else y tabulo, me quedo sin pantalla . De hecho, como comente, mi costumbre era esa, hacer el return cuando quisiera, pero pensandolo estructuradamente, y ya que intento hacer una implementación para el "mundo en general" mejor hacerlo "bien", como he tenido que hacer en funciones como duplicaPila y demás.

Sigo pensando que el modo que tengo de crearPilas es ineficiente, y tendre que modificarlo para optimizarlo. Por ahora uso un array, pero esta claro que debo controlar mejor los "huecos" de ese array cuando se liberen.

He estado pensando en las funciones de ordenar el contenido de las pilas, me parece que no terminan de ser muy útiles y pueden ser bastante complicadas. La finalidad de usar una pila es para usar el concepto de LIFO (last input first output), ¿quien va a querer ordenarlas? Para eso, que use una lista enlazada (que tambien me he propuesto implementar, en cuanto acabe esto ). Además, en algún momento tendre que echar el freno, si no, no termino de implementar nunca la librería. ¿Qué opinais?

Así que centrémonos en lo que llevo hecho. ¿Alguna función más que sea realmente útil para el manejo de pilas? Por ahora, lo que pretendo modificar es la administración de las pilas (creación y demás). Estoy abierto a cualquier opinion para refinar esto.

Adjunto un ZIP con el fichero .h y el fichero .c que si no voy a saturar este post con tado XCODE.

Muchas gracias a todos!!!

Nos vemos  

Bueno en esta epoca es muy complicado...
tratare de sar tiempo luego para continuar con el proyecto.

Isa la LPL, es un proyecto que estamos haciendo con unos amigo . bueno yo no he hecho nada...  
www.telepormedia.com/foro

Hola! que alegría saber que lo que uno hace es util!

Ahora mismo estoy de examenes, por eso tengo este proyecto un poco de parón (va ya un mes...). Pero en cuanto acabe quiero terminar esta implementación y comenzar otra.

De esta implementación solo me faltaba terminar la documentación, pero ahora que me comentas eso, lo estudiaré para ver si podemos refinarla un poco más. Al fin y al cabo lo que quiero hacer es una implementación lo más útil para "todo el mundo", con las funciones básicas que siempre se necesitan.

Después de la pila estoy pensando en una lista enlazada, que también es una estructura muy utilizada. Más adelante espero adentrarme en cosas "extrañas" del estilo de árboles B, tablas hash y demás. Todo a su tiempo.

Nos vemos