Print reverse stack

Question

I need to create a function that prints a reverse stack. I did the void implementation pilha_inverted (Stack *p), but when I use pilha_pop the execution stops and is finished. The problem does not occur when using the pilha_displays function instead of the reversed pilha_function.

void pilha_invertida(Pilha *p) {

    Pilha *aux, *aux2 = pilha_cria();
    aux = p;

    char c[8];

    while(!pilha_vazia(aux)) {
        strcpy(c, pilha_pop(aux));
        pilha_push(aux2, c);
    }

    pilha_exibe(aux2);

}

pilha_pop

char* pilha_pop(Pilha* p){

    Elemento* t;
    char *v;

    if(pilha_vazia(p)){
         //printf("Pilha vazia.\n");
         //return 0;
    }

    t = p->prim;
    v = t->descricao;
    p->prim= t->prox;
    free(t);
    p->q = p->q - 1;
    return v;
}

struct:

typedef struct elemento{

  char descricao[8];
  struct elemento* prox;

}Elemento;

typedef struct pilha{

   int q;
   Elemento* prim;

}Pilha;

main:

int main() {

   Pilha **p;

   int nf = 2, nc = 3;

   p = (Pilha**) malloc(nf * sizeof(Pilha*));

  for(i = 0; i < nf; i++){

    p[i] = (Pilha*) malloc(nc * sizeof(Pilha));
    p[i] = pilha_cria();

  }

  pilha_push(p[0], "ABCD");
  pilha_push(p[0], "QWER");
  pilha_pop(p[0]);
  pilha_push(p[0], "POIU");

  pilha_invertida(p[0]);
}

Answer 1

Follow a simple example:

#include <stdio.h>
#include <stdlib.h>


typedef struct item {
    char descricao[256];
} Item;

typedef struct no {
    Item *item;

    struct no *anterior;
    struct no *proximo;
} No;

typedef struct pilha {
    size_t tamanho;
    No *primeiro;
    No *utlimo;
} Pilha;


Pilha *criarPilha();

void inserirNaPilha(Pilha *pilha, Item *item);

void listar(Pilha *pilha);

void listarInverso(Pilha *pilha);


int main() {
    Pilha *pilha = criarPilha();

    if (pilha == NULL) {
        fprintf(stderr, "[ E ]: Erro ao criar a pilha. \n");
        exit(EXIT_FAILURE);
    }

    inserirNaPilha(pilha, &(Item) {"Primeiro"});
    inserirNaPilha(pilha, &(Item) {"Segundo"});
    inserirNaPilha(pilha, &(Item) {"Terceiro"});
    inserirNaPilha(pilha, &(Item) {"Quarto"});
    inserirNaPilha(pilha, &(Item) {"Quinto"});

    printf(">> Lista normal. \n");
    listar(pilha);

    printf(">> Lista inversa. \n");
    listarInverso(pilha);

    return EXIT_SUCCESS;
}


Pilha *criarPilha() {
    Pilha *pilha = (Pilha *) malloc(sizeof(Pilha));
    pilha->tamanho = 0;
    pilha->primeiro = NULL;
    pilha->utlimo = NULL;

    return pilha;
}

void inserirNaPilha(Pilha *pilha, Item *item) {
    No *novo = (No *) malloc(sizeof(No));
    novo->item = item;
    novo->anterior = NULL;
    novo->proximo = NULL;

    if (pilha->tamanho == 0) {
        pilha->primeiro = novo;
    } else {
        No *no = pilha->primeiro;

        while (no->proximo != NULL) {
            no = no->proximo;
        }

        no->proximo = novo;
        novo->anterior = no;
    }

    pilha->utlimo = novo;
    pilha->tamanho += 1;
}

void listar(Pilha *pilha) {
    No *no = pilha->primeiro;

    while (no != NULL) {
        printf("Item: %s \n", no->item->descricao);
        no = no->proximo;
    }
}

void listarInverso(Pilha *pilha) {
    No *no = pilha->utlimo;

    while (no != NULL) {
        printf("Item: %s \n", no->item->descricao);
        no = no->anterior;
    }
}